1 using System;
    2 using System.Collections;
    3 using System.Text.Parsing;
    4 
    5 // this source file has been automatically generated from 'IntermediateCodeFileGrammar.parser' using cmparsergen version 2.0.0.
    6 
    7 namespace cmsx.intermediate
    8 {
    9     public class IntermediateCodeFileGrammar : System.Text.Parsing.Grammar
   10     {
   11         public IntermediateCodeFileGrammar() : this(new ParsingDomain())
   12         {
   13         }
   14         public IntermediateCodeFileGrammar(ParsingDomain* parsingDomain) : base(ToUtf32("IntermediateCodeFileGrammar"), parsingDomain->GetNamespaceScope(ToUtf32("cmsx.intermediate")), parsingDomain)
   15         {
   16             SetOwner(0);
   17             keywords0.Add(ToUtf32("void"));
   18             keywords0.Add(ToUtf32("byte"));
   19             keywords0.Add(ToUtf32("float"));
   20             keywords0.Add(ToUtf32("uint"));
   21             keywords0.Add(ToUtf32("bool"));
   22             keywords0.Add(ToUtf32("long"));
   23             keywords0.Add(ToUtf32("ushort"));
   24             keywords0.Add(ToUtf32("ulong"));
   25             keywords0.Add(ToUtf32("double"));
   26             keywords0.Add(ToUtf32("int"));
   27             keywords0.Add(ToUtf32("sbyte"));
   28             keywords0.Add(ToUtf32("short"));
   29             RegisterParsingDomain(parsingDomain);
   30             parsingDomain->AddGrammar(this);
   31             CreateRules();
   32             Link();
   33         }
   34         public void Parse(const uchar* start, const uchar* end, int fileIndex, const string& fileName, cmsx.intermediate.Context* context)
   35         {
   36             Scanner scanner(start, end, fileName, fileIndex, SkipRule());
   37             UniquePtr<XmlLog> xmlLog;
   38             if (Log() != null)
   39             {
   40                 xmlLog.Reset(new XmlLog(*Log(), MaxLogLineLength()));
   41                 scanner.SetLog(xmlLog.Get());
   42                 xmlLog->WriteBeginRule( u"parse");
   43                 xmlLog->IncIndent();
   44             }
   45             Stack<UniquePtr<Object>> stack;
   46             UniquePtr<ParsingData> parsingData(new ParsingData(Domain()->NumRules()));
   47             scanner.SetParsingData(parsingData.Get());
   48             stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context)));
   49             Match match = base->Parse(scanner, stack, parsingData.Get());
   50             Span stop = scanner.GetSpan();
   51             if (Log() != null)
   52             {
   53                 xmlLog->DecIndent();
   54                 xmlLog->WriteEndRule( u"parse");
   55             }
   56             if (!match.Hit() || stop.start != cast<int>(end - start))
   57             {
   58                 if (StartRule() != null)
   59                 {
   60                     throw ExpectationFailure(StartRule()->Info(), fileName, stop, start, end);
   61                 }
   62                 else
   63                 {
   64                     throw ParsingException("grammar '" + ToUtf8(Name()) + "' has no start rule", fileName, scanner.GetSpan(), start, end);
   65                 }
   66             }
   67         }
   68 
   69         public class IntermediateCodeFileRule : System.Text.Parsing.RuleParser
   70         {
   71             public IntermediateCodeFileRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
   72             {
   73                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
   74             }
   75             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
   76             {
   77                 parsingData->PushContext(Id(), new Context());
   78                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
   79                 UniquePtr<Object> context_value = stack.Pop();
   80                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
   81             }
   82             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
   83             {
   84                 parsingData->PopContext(Id());
   85             }
   86             public override void Link()
   87             {
   88                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
   89                 a0ActionParser->SetAction(A0Action);
   90                 NonterminalParser* compileUnitHeaderNonterminalParser = GetNonterminal(ToUtf32("CompileUnitHeader"));
   91                 compileUnitHeaderNonterminalParser->SetPre(PreCompileUnitHeader);
   92                 NonterminalParser* typeDeclarationsNonterminalParser = GetNonterminal(ToUtf32("TypeDeclarations"));
   93                 typeDeclarationsNonterminalParser->SetPre(PreTypeDeclarations);
   94                 NonterminalParser* dataDefinitionsNonterminalParser = GetNonterminal(ToUtf32("DataDefinitions"));
   95                 dataDefinitionsNonterminalParser->SetPre(PreDataDefinitions);
   96                 NonterminalParser* functionsNonterminalParser = GetNonterminal(ToUtf32("Functions"));
   97                 functionsNonterminalParser->SetPre(PreFunctions);
   98                 NonterminalParser* metadataNonterminalParser = GetNonterminal(ToUtf32("Metadata"));
   99                 metadataNonterminalParser->SetPre(PreMetadata);
  100             }
  101             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  102             {
  103                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  104                 context->context->SetFileName(fileName);
  105             }
  106             public void PreCompileUnitHeader(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  107             {
  108                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  109                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  110             }
  111             public void PreTypeDeclarations(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  112             {
  113                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  114                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  115             }
  116             public void PreDataDefinitions(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  117             {
  118                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  119                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  120             }
  121             public void PreFunctions(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  122             {
  123                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  124                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  125             }
  126             public void PreMetadata(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  127             {
  128                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  129                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  130             }
  131             public class Context : System.Text.Parsing.Context
  132             {
  133                 public Context() : context()
  134                 {
  135                 }
  136                 public cmsx.intermediate.Context* context;
  137             }
  138         }
  139 
  140         public class CompileUnitHeaderRule : System.Text.Parsing.RuleParser
  141         {
  142             public CompileUnitHeaderRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  143             {
  144                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  145                 AddLocalVariable(AttrOrVar(ToUtf32("string"), ToUtf32("compileUnitId")));
  146                 AddLocalVariable(AttrOrVar(ToUtf32("MDStructRef*"), ToUtf32("mdRef")));
  147             }
  148             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  149             {
  150                 parsingData->PushContext(Id(), new Context());
  151                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  152                 UniquePtr<Object> context_value = stack.Pop();
  153                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  154             }
  155             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  156             {
  157                 parsingData->PopContext(Id());
  158             }
  159             public override void Link()
  160             {
  161                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  162                 a0ActionParser->SetAction(A0Action);
  163                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
  164                 a1ActionParser->SetAction(A1Action);
  165                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
  166                 a2ActionParser->SetAction(A2Action);
  167                 NonterminalParser* mDStructRefNonterminalParser = GetNonterminal(ToUtf32("MDStructRef"));
  168                 mDStructRefNonterminalParser->SetPre(PreMDStructRef);
  169                 mDStructRefNonterminalParser->SetPost(PostMDStructRef);
  170             }
  171             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  172             {
  173                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  174                 context->context->SetCompileUnitInfo(context->compileUnitId, context->mdRef);
  175             }
  176             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  177             {
  178                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  179                 context->compileUnitId = ToUtf8(ustring(matchBegin, matchEnd));
  180             }
  181             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  182             {
  183                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  184                 context->mdRef = context->fromMDStructRef;
  185             }
  186             public void PreMDStructRef(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  187             {
  188                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  189                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  190             }
  191             public void PostMDStructRef(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  192             {
  193                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  194                 if (matched)
  195                 {
  196                     UniquePtr<Object> fromMDStructRef_value = stack.Pop();
  197                     context->fromMDStructRef = *cast<ValueObject<MDStructRef*>*>(fromMDStructRef_value.Get());
  198                 }
  199             }
  200             public class Context : System.Text.Parsing.Context
  201             {
  202                 public Context() : context(), compileUnitId(), mdRef(), fromMDStructRef()
  203                 {
  204                 }
  205                 public cmsx.intermediate.Context* context;
  206                 public string compileUnitId;
  207                 public MDStructRef* mdRef;
  208                 public MDStructRef* fromMDStructRef;
  209             }
  210         }
  211 
  212         public class TypeDeclarationsRule : System.Text.Parsing.RuleParser
  213         {
  214             public TypeDeclarationsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  215             {
  216                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  217             }
  218             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  219             {
  220                 parsingData->PushContext(Id(), new Context());
  221                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  222                 UniquePtr<Object> context_value = stack.Pop();
  223                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  224             }
  225             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  226             {
  227                 parsingData->PopContext(Id());
  228             }
  229             public override void Link()
  230             {
  231                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  232                 a0ActionParser->SetAction(A0Action);
  233                 NonterminalParser* typeDeclarationNonterminalParser = GetNonterminal(ToUtf32("TypeDeclaration"));
  234                 typeDeclarationNonterminalParser->SetPre(PreTypeDeclaration);
  235             }
  236             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  237             {
  238                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  239                 context->context->ResolveTypes();
  240             }
  241             public void PreTypeDeclaration(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  242             {
  243                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  244                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  245             }
  246             public class Context : System.Text.Parsing.Context
  247             {
  248                 public Context() : context()
  249                 {
  250                 }
  251                 public cmsx.intermediate.Context* context;
  252             }
  253         }
  254 
  255         public class DataDefinitionsRule : System.Text.Parsing.RuleParser
  256         {
  257             public DataDefinitionsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  258             {
  259                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  260             }
  261             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  262             {
  263                 parsingData->PushContext(Id(), new Context());
  264                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  265                 UniquePtr<Object> context_value = stack.Pop();
  266                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  267             }
  268             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  269             {
  270                 parsingData->PopContext(Id());
  271             }
  272             public override void Link()
  273             {
  274                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  275                 a0ActionParser->SetAction(A0Action);
  276                 NonterminalParser* dataDefinitionNonterminalParser = GetNonterminal(ToUtf32("DataDefinition"));
  277                 dataDefinitionNonterminalParser->SetPre(PreDataDefinition);
  278             }
  279             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  280             {
  281                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  282                 context->context->ValidateGlobalVariables();
  283             }
  284             public void PreDataDefinition(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  285             {
  286                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  287                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  288             }
  289             public class Context : System.Text.Parsing.Context
  290             {
  291                 public Context() : context()
  292                 {
  293                 }
  294                 public cmsx.intermediate.Context* context;
  295             }
  296         }
  297 
  298         public class FunctionsRule : System.Text.Parsing.RuleParser
  299         {
  300             public FunctionsRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  301             {
  302                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  303             }
  304             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  305             {
  306                 parsingData->PushContext(Id(), new Context());
  307                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  308                 UniquePtr<Object> context_value = stack.Pop();
  309                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  310             }
  311             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  312             {
  313                 parsingData->PopContext(Id());
  314             }
  315             public override void Link()
  316             {
  317                 NonterminalParser* functionNonterminalParser = GetNonterminal(ToUtf32("Function"));
  318                 functionNonterminalParser->SetPre(PreFunction);
  319             }
  320             public void PreFunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  321             {
  322                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  323                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  324             }
  325             public class Context : System.Text.Parsing.Context
  326             {
  327                 public Context() : context()
  328                 {
  329                 }
  330                 public cmsx.intermediate.Context* context;
  331             }
  332         }
  333 
  334         public class FunctionRule : System.Text.Parsing.RuleParser
  335         {
  336             public FunctionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  337             {
  338                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  339             }
  340             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  341             {
  342                 parsingData->PushContext(Id(), new Context());
  343                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  344                 UniquePtr<Object> context_value = stack.Pop();
  345                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  346             }
  347             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  348             {
  349                 parsingData->PopContext(Id());
  350             }
  351             public override void Link()
  352             {
  353                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  354                 a0ActionParser->SetAction(A0Action);
  355                 NonterminalParser* functionNonterminalParser = GetNonterminal(ToUtf32("function"));
  356                 functionNonterminalParser->SetPre(Prefunction);
  357                 functionNonterminalParser->SetPost(Postfunction);
  358                 NonterminalParser* basicBlockNonterminalParser = GetNonterminal(ToUtf32("BasicBlock"));
  359                 basicBlockNonterminalParser->SetPre(PreBasicBlock);
  360             }
  361             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  362             {
  363                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  364                 context->context->SetCurrentFunction(context->fromfunction);
  365             }
  366             public void Prefunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  367             {
  368                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  369                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  370             }
  371             public void Postfunction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  372             {
  373                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  374                 if (matched)
  375                 {
  376                     UniquePtr<Object> fromfunction_value = stack.Pop();
  377                     context->fromfunction = *cast<ValueObject<Function*>*>(fromfunction_value.Get());
  378                 }
  379             }
  380             public void PreBasicBlock(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  381             {
  382                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  383                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  384                 stack.Push(UniquePtr<Object>(new ValueObject<Function*>(context->fromfunction)));
  385             }
  386             public class Context : System.Text.Parsing.Context
  387             {
  388                 public Context() : context(), fromfunction()
  389                 {
  390                 }
  391                 public cmsx.intermediate.Context* context;
  392                 public Function* fromfunction;
  393             }
  394         }
  395 
  396         public class FunctionHeaderRule : System.Text.Parsing.RuleParser
  397         {
  398             public FunctionHeaderRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  399             {
  400                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  401                 SetValueTypeName(ToUtf32("Function*"));
  402                 AddLocalVariable(AttrOrVar(ToUtf32("bool"), ToUtf32("once")));
  403             }
  404             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  405             {
  406                 parsingData->PushContext(Id(), new Context());
  407                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  408                 UniquePtr<Object> context_value = stack.Pop();
  409                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  410             }
  411             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  412             {
  413                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  414                 if (matched)
  415                 {
  416                     stack.Push(UniquePtr<Object>(new ValueObject<Function*>(context->value)));
  417                 }
  418                 parsingData->PopContext(Id());
  419             }
  420             public override void Link()
  421             {
  422                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  423                 a0ActionParser->SetAction(A0Action);
  424                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
  425                 a1ActionParser->SetAction(A1Action);
  426                 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
  427                 functionTypeNonterminalParser->SetPre(PrefunctionType);
  428                 functionTypeNonterminalParser->SetPost(PostfunctionType);
  429                 NonterminalParser* functionIdNonterminalParser = GetNonterminal(ToUtf32("functionId"));
  430                 functionIdNonterminalParser->SetPost(PostfunctionId);
  431                 NonterminalParser* mdNonterminalParser = GetNonterminal(ToUtf32("md"));
  432                 mdNonterminalParser->SetPre(Premd);
  433                 mdNonterminalParser->SetPost(Postmd);
  434             }
  435             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  436             {
  437                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  438                 context->once = true;
  439             }
  440             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  441             {
  442                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  443                 context->value = context->context->AddFunction(span.lineNumber, context->fromfunctionType, ToUtf8(context->fromfunctionId), context->once, context->frommd);
  444             }
  445             public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  446             {
  447                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  448                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  449             }
  450             public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  451             {
  452                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  453                 if (matched)
  454                 {
  455                     UniquePtr<Object> fromfunctionType_value = stack.Pop();
  456                     context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
  457                 }
  458             }
  459             public void PostfunctionId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  460             {
  461                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  462                 if (matched)
  463                 {
  464                     UniquePtr<Object> fromfunctionId_value = stack.Pop();
  465                     context->fromfunctionId = *cast<ValueObject<ustring>*>(fromfunctionId_value.Get());
  466                 }
  467             }
  468             public void Premd(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  469             {
  470                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  471                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  472             }
  473             public void Postmd(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  474             {
  475                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  476                 if (matched)
  477                 {
  478                     UniquePtr<Object> frommd_value = stack.Pop();
  479                     context->frommd = *cast<ValueObject<MDStructRef*>*>(frommd_value.Get());
  480                 }
  481             }
  482             public class Context : System.Text.Parsing.Context
  483             {
  484                 public Context() : context(), value(), once(), fromfunctionType(), fromfunctionId(), frommd()
  485                 {
  486                 }
  487                 public cmsx.intermediate.Context* context;
  488                 public Function* value;
  489                 public bool once;
  490                 public Type* fromfunctionType;
  491                 public ustring fromfunctionId;
  492                 public MDStructRef* frommd;
  493             }
  494         }
  495 
  496         public class BasicBlockRule : System.Text.Parsing.RuleParser
  497         {
  498             public BasicBlockRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  499             {
  500                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  501                 AddInheritedAttribute(AttrOrVar(ToUtf32("Function*"), ToUtf32("function")));
  502                 AddLocalVariable(AttrOrVar(ToUtf32("BasicBlock*"), ToUtf32("bb")));
  503             }
  504             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  505             {
  506                 parsingData->PushContext(Id(), new Context());
  507                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  508                 UniquePtr<Object> function_value = stack.Pop();
  509                 context->function = *cast<ValueObject<Function*>*>(function_value.Get());
  510                 UniquePtr<Object> context_value = stack.Pop();
  511                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  512             }
  513             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  514             {
  515                 parsingData->PopContext(Id());
  516             }
  517             public override void Link()
  518             {
  519                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  520                 a0ActionParser->SetAction(A0Action);
  521                 NonterminalParser* idNonterminalParser = GetNonterminal(ToUtf32("id"));
  522                 idNonterminalParser->SetPost(Postid);
  523                 NonterminalParser* instructionLineNonterminalParser = GetNonterminal(ToUtf32("InstructionLine"));
  524                 instructionLineNonterminalParser->SetPre(PreInstructionLine);
  525             }
  526             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  527             {
  528                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  529                 context->bb = context->function->AddBasicBlock(context->fromid);
  530             }
  531             public void Postid(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  532             {
  533                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  534                 if (matched)
  535                 {
  536                     UniquePtr<Object> fromid_value = stack.Pop();
  537                     context->fromid = *cast<ValueObject<uint>*>(fromid_value.Get());
  538                 }
  539             }
  540             public void PreInstructionLine(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  541             {
  542                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  543                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  544                 stack.Push(UniquePtr<Object>(new ValueObject<BasicBlock*>(context->bb)));
  545             }
  546             public class Context : System.Text.Parsing.Context
  547             {
  548                 public Context() : context(), function(), bb(), fromid()
  549                 {
  550                 }
  551                 public cmsx.intermediate.Context* context;
  552                 public Function* function;
  553                 public BasicBlock* bb;
  554                 public uint fromid;
  555             }
  556         }
  557 
  558         public class InstructionLineRule : System.Text.Parsing.RuleParser
  559         {
  560             public InstructionLineRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  561             {
  562                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  563                 AddInheritedAttribute(AttrOrVar(ToUtf32("BasicBlock*"), ToUtf32("bb")));
  564             }
  565             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  566             {
  567                 parsingData->PushContext(Id(), new Context());
  568                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  569                 UniquePtr<Object> bb_value = stack.Pop();
  570                 context->bb = *cast<ValueObject<BasicBlock*>*>(bb_value.Get());
  571                 UniquePtr<Object> context_value = stack.Pop();
  572                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  573             }
  574             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  575             {
  576                 parsingData->PopContext(Id());
  577             }
  578             public override void Link()
  579             {
  580                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  581                 a0ActionParser->SetAction(A0Action);
  582                 NonterminalParser* instructionNonterminalParser = GetNonterminal(ToUtf32("Instruction"));
  583                 instructionNonterminalParser->SetPre(PreInstruction);
  584                 instructionNonterminalParser->SetPost(PostInstruction);
  585                 NonterminalParser* lineInfoNonterminalParser = GetNonterminal(ToUtf32("lineInfo"));
  586                 lineInfoNonterminalParser->SetPre(PrelineInfo);
  587                 lineInfoNonterminalParser->SetPost(PostlineInfo);
  588             }
  589             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  590             {
  591                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  592                 context->bb->AddInstruction(context->fromInstruction, context->fromlineInfo);
  593             }
  594             public void PreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  595             {
  596                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  597                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  598             }
  599             public void PostInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  600             {
  601                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  602                 if (matched)
  603                 {
  604                     UniquePtr<Object> fromInstruction_value = stack.Pop();
  605                     context->fromInstruction = *cast<ValueObject<Instruction*>*>(fromInstruction_value.Get());
  606                 }
  607             }
  608             public void PrelineInfo(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  609             {
  610                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  611                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  612             }
  613             public void PostlineInfo(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  614             {
  615                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  616                 if (matched)
  617                 {
  618                     UniquePtr<Object> fromlineInfo_value = stack.Pop();
  619                     context->fromlineInfo = *cast<ValueObject<MDStructRef*>*>(fromlineInfo_value.Get());
  620                 }
  621             }
  622             public class Context : System.Text.Parsing.Context
  623             {
  624                 public Context() : context(), bb(), fromInstruction(), fromlineInfo()
  625                 {
  626                 }
  627                 public cmsx.intermediate.Context* context;
  628                 public BasicBlock* bb;
  629                 public Instruction* fromInstruction;
  630                 public MDStructRef* fromlineInfo;
  631             }
  632         }
  633 
  634         public class InstructionRule : System.Text.Parsing.RuleParser
  635         {
  636             public InstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  637             {
  638                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  639                 SetValueTypeName(ToUtf32("Instruction*"));
  640             }
  641             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  642             {
  643                 parsingData->PushContext(Id(), new Context());
  644                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  645                 UniquePtr<Object> context_value = stack.Pop();
  646                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  647             }
  648             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  649             {
  650                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  651                 if (matched)
  652                 {
  653                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
  654                 }
  655                 parsingData->PopContext(Id());
  656             }
  657             public override void Link()
  658             {
  659                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  660                 a0ActionParser->SetAction(A0Action);
  661                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
  662                 a1ActionParser->SetAction(A1Action);
  663                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
  664                 a2ActionParser->SetAction(A2Action);
  665                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
  666                 a3ActionParser->SetAction(A3Action);
  667                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
  668                 a4ActionParser->SetAction(A4Action);
  669                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
  670                 a5ActionParser->SetAction(A5Action);
  671                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
  672                 a6ActionParser->SetAction(A6Action);
  673                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
  674                 a7ActionParser->SetAction(A7Action);
  675                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
  676                 a8ActionParser->SetAction(A8Action);
  677                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
  678                 a9ActionParser->SetAction(A9Action);
  679                 NonterminalParser* storeInstructionNonterminalParser = GetNonterminal(ToUtf32("StoreInstruction"));
  680                 storeInstructionNonterminalParser->SetPre(PreStoreInstruction);
  681                 storeInstructionNonterminalParser->SetPost(PostStoreInstruction);
  682                 NonterminalParser* argInstructionNonterminalParser = GetNonterminal(ToUtf32("ArgInstruction"));
  683                 argInstructionNonterminalParser->SetPre(PreArgInstruction);
  684                 argInstructionNonterminalParser->SetPost(PostArgInstruction);
  685                 NonterminalParser* jumpInstructionNonterminalParser = GetNonterminal(ToUtf32("JumpInstruction"));
  686                 jumpInstructionNonterminalParser->SetPre(PreJumpInstruction);
  687                 jumpInstructionNonterminalParser->SetPost(PostJumpInstruction);
  688                 NonterminalParser* branchInstructionNonterminalParser = GetNonterminal(ToUtf32("BranchInstruction"));
  689                 branchInstructionNonterminalParser->SetPre(PreBranchInstruction);
  690                 branchInstructionNonterminalParser->SetPost(PostBranchInstruction);
  691                 NonterminalParser* procedureCallInstructionNonterminalParser = GetNonterminal(ToUtf32("ProcedureCallInstruction"));
  692                 procedureCallInstructionNonterminalParser->SetPre(PreProcedureCallInstruction);
  693                 procedureCallInstructionNonterminalParser->SetPost(PostProcedureCallInstruction);
  694                 NonterminalParser* retInstructionNonterminalParser = GetNonterminal(ToUtf32("RetInstruction"));
  695                 retInstructionNonterminalParser->SetPre(PreRetInstruction);
  696                 retInstructionNonterminalParser->SetPost(PostRetInstruction);
  697                 NonterminalParser* switchInstructionNonterminalParser = GetNonterminal(ToUtf32("SwitchInstruction"));
  698                 switchInstructionNonterminalParser->SetPre(PreSwitchInstruction);
  699                 switchInstructionNonterminalParser->SetPost(PostSwitchInstruction);
  700                 NonterminalParser* valueInstructionNonterminalParser = GetNonterminal(ToUtf32("ValueInstruction"));
  701                 valueInstructionNonterminalParser->SetPre(PreValueInstruction);
  702                 valueInstructionNonterminalParser->SetPost(PostValueInstruction);
  703                 NonterminalParser* noOperationInstructionNonterminalParser = GetNonterminal(ToUtf32("NoOperationInstruction"));
  704                 noOperationInstructionNonterminalParser->SetPre(PreNoOperationInstruction);
  705                 noOperationInstructionNonterminalParser->SetPost(PostNoOperationInstruction);
  706                 NonterminalParser* saveInstructionNonterminalParser = GetNonterminal(ToUtf32("SaveInstruction"));
  707                 saveInstructionNonterminalParser->SetPre(PreSaveInstruction);
  708                 saveInstructionNonterminalParser->SetPost(PostSaveInstruction);
  709             }
  710             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  711             {
  712                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  713                 context->value = context->fromStoreInstruction;
  714             }
  715             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  716             {
  717                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  718                 context->value = context->fromArgInstruction;
  719             }
  720             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  721             {
  722                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  723                 context->value = context->fromJumpInstruction;
  724             }
  725             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  726             {
  727                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  728                 context->value = context->fromBranchInstruction;
  729             }
  730             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  731             {
  732                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  733                 context->value = context->fromProcedureCallInstruction;
  734             }
  735             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  736             {
  737                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  738                 context->value = context->fromRetInstruction;
  739             }
  740             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  741             {
  742                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  743                 context->value = context->fromSwitchInstruction;
  744             }
  745             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  746             {
  747                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  748                 context->value = context->fromValueInstruction;
  749             }
  750             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  751             {
  752                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  753                 context->value = context->fromNoOperationInstruction;
  754             }
  755             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  756             {
  757                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  758                 context->value = context->fromSaveInstruction;
  759             }
  760             public void PreStoreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  761             {
  762                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  763                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  764             }
  765             public void PostStoreInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  766             {
  767                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  768                 if (matched)
  769                 {
  770                     UniquePtr<Object> fromStoreInstruction_value = stack.Pop();
  771                     context->fromStoreInstruction = *cast<ValueObject<Instruction*>*>(fromStoreInstruction_value.Get());
  772                 }
  773             }
  774             public void PreArgInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  775             {
  776                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  777                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  778             }
  779             public void PostArgInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  780             {
  781                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  782                 if (matched)
  783                 {
  784                     UniquePtr<Object> fromArgInstruction_value = stack.Pop();
  785                     context->fromArgInstruction = *cast<ValueObject<Instruction*>*>(fromArgInstruction_value.Get());
  786                 }
  787             }
  788             public void PreJumpInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  789             {
  790                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  791                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  792             }
  793             public void PostJumpInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  794             {
  795                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  796                 if (matched)
  797                 {
  798                     UniquePtr<Object> fromJumpInstruction_value = stack.Pop();
  799                     context->fromJumpInstruction = *cast<ValueObject<Instruction*>*>(fromJumpInstruction_value.Get());
  800                 }
  801             }
  802             public void PreBranchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  803             {
  804                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  805                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  806             }
  807             public void PostBranchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  808             {
  809                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  810                 if (matched)
  811                 {
  812                     UniquePtr<Object> fromBranchInstruction_value = stack.Pop();
  813                     context->fromBranchInstruction = *cast<ValueObject<Instruction*>*>(fromBranchInstruction_value.Get());
  814                 }
  815             }
  816             public void PreProcedureCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  817             {
  818                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  819                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  820             }
  821             public void PostProcedureCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  822             {
  823                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  824                 if (matched)
  825                 {
  826                     UniquePtr<Object> fromProcedureCallInstruction_value = stack.Pop();
  827                     context->fromProcedureCallInstruction = *cast<ValueObject<Instruction*>*>(fromProcedureCallInstruction_value.Get());
  828                 }
  829             }
  830             public void PreRetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  831             {
  832                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  833                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  834             }
  835             public void PostRetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  836             {
  837                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  838                 if (matched)
  839                 {
  840                     UniquePtr<Object> fromRetInstruction_value = stack.Pop();
  841                     context->fromRetInstruction = *cast<ValueObject<Instruction*>*>(fromRetInstruction_value.Get());
  842                 }
  843             }
  844             public void PreSwitchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  845             {
  846                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  847                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  848             }
  849             public void PostSwitchInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  850             {
  851                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  852                 if (matched)
  853                 {
  854                     UniquePtr<Object> fromSwitchInstruction_value = stack.Pop();
  855                     context->fromSwitchInstruction = *cast<ValueObject<SwitchInstruction*>*>(fromSwitchInstruction_value.Get());
  856                 }
  857             }
  858             public void PreValueInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  859             {
  860                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  861                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  862             }
  863             public void PostValueInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  864             {
  865                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  866                 if (matched)
  867                 {
  868                     UniquePtr<Object> fromValueInstruction_value = stack.Pop();
  869                     context->fromValueInstruction = *cast<ValueObject<Instruction*>*>(fromValueInstruction_value.Get());
  870                 }
  871             }
  872             public void PreNoOperationInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  873             {
  874                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  875                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  876             }
  877             public void PostNoOperationInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  878             {
  879                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  880                 if (matched)
  881                 {
  882                     UniquePtr<Object> fromNoOperationInstruction_value = stack.Pop();
  883                     context->fromNoOperationInstruction = *cast<ValueObject<Instruction*>*>(fromNoOperationInstruction_value.Get());
  884                 }
  885             }
  886             public void PreSaveInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  887             {
  888                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  889                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  890             }
  891             public void PostSaveInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  892             {
  893                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  894                 if (matched)
  895                 {
  896                     UniquePtr<Object> fromSaveInstruction_value = stack.Pop();
  897                     context->fromSaveInstruction = *cast<ValueObject<Instruction*>*>(fromSaveInstruction_value.Get());
  898                 }
  899             }
  900             public class Context : System.Text.Parsing.Context
  901             {
  902                 public Context() : context(), value(), fromStoreInstruction(), fromArgInstruction(), fromJumpInstruction(), fromBranchInstruction(), fromProcedureCallInstruction(), fromRetInstruction(), fromSwitchInstruction(), fromValueInstruction(), fromNoOperationInstruction(), fromSaveInstruction()
  903                 {
  904                 }
  905                 public cmsx.intermediate.Context* context;
  906                 public Instruction* value;
  907                 public Instruction* fromStoreInstruction;
  908                 public Instruction* fromArgInstruction;
  909                 public Instruction* fromJumpInstruction;
  910                 public Instruction* fromBranchInstruction;
  911                 public Instruction* fromProcedureCallInstruction;
  912                 public Instruction* fromRetInstruction;
  913                 public SwitchInstruction* fromSwitchInstruction;
  914                 public Instruction* fromValueInstruction;
  915                 public Instruction* fromNoOperationInstruction;
  916                 public Instruction* fromSaveInstruction;
  917             }
  918         }
  919 
  920         public class StoreInstructionRule : System.Text.Parsing.RuleParser
  921         {
  922             public StoreInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
  923             {
  924                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
  925                 SetValueTypeName(ToUtf32("Instruction*"));
  926             }
  927             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  928             {
  929                 parsingData->PushContext(Id(), new Context());
  930                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  931                 UniquePtr<Object> context_value = stack.Pop();
  932                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
  933             }
  934             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  935             {
  936                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  937                 if (matched)
  938                 {
  939                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
  940                 }
  941                 parsingData->PopContext(Id());
  942             }
  943             public override void Link()
  944             {
  945                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
  946                 a0ActionParser->SetAction(A0Action);
  947                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
  948                 typeNonterminalParser->SetPre(Pretype);
  949                 typeNonterminalParser->SetPost(Posttype);
  950                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
  951                 valNonterminalParser->SetPre(Preval);
  952                 valNonterminalParser->SetPost(Postval);
  953                 NonterminalParser* ptrTypeNonterminalParser = GetNonterminal(ToUtf32("ptrType"));
  954                 ptrTypeNonterminalParser->SetPre(PreptrType);
  955                 ptrTypeNonterminalParser->SetPost(PostptrType);
  956                 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
  957                 ptrNonterminalParser->SetPre(Preptr);
  958                 ptrNonterminalParser->SetPost(Postptr);
  959             }
  960             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
  961             {
  962                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  963                 context->value = new StoreInstruction(context->fromval, context->fromptr, span.lineNumber);
  964             }
  965             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  966             {
  967                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  968                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  969             }
  970             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  971             {
  972                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  973                 if (matched)
  974                 {
  975                     UniquePtr<Object> fromtype_value = stack.Pop();
  976                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
  977                 }
  978             }
  979             public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  980             {
  981                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  982                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  983                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
  984             }
  985             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
  986             {
  987                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  988                 if (matched)
  989                 {
  990                     UniquePtr<Object> fromval_value = stack.Pop();
  991                     context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
  992                 }
  993             }
  994             public void PreptrType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
  995             {
  996                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
  997                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
  998             }
  999             public void PostptrType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1000             {
 1001                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1002                 if (matched)
 1003                 {
 1004                     UniquePtr<Object> fromptrType_value = stack.Pop();
 1005                     context->fromptrType = *cast<ValueObject<Type*>*>(fromptrType_value.Get());
 1006                 }
 1007             }
 1008             public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1009             {
 1010                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1011                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1012                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromptrType)));
 1013             }
 1014             public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1015             {
 1016                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1017                 if (matched)
 1018                 {
 1019                     UniquePtr<Object> fromptr_value = stack.Pop();
 1020                     context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
 1021                 }
 1022             }
 1023             public class Context : System.Text.Parsing.Context
 1024             {
 1025                 public Context() : context(), value(), fromtype(), fromval(), fromptrType(), fromptr()
 1026                 {
 1027                 }
 1028                 public cmsx.intermediate.Context* context;
 1029                 public Instruction* value;
 1030                 public Type* fromtype;
 1031                 public Value* fromval;
 1032                 public Type* fromptrType;
 1033                 public Value* fromptr;
 1034             }
 1035         }
 1036 
 1037         public class ArgInstructionRule : System.Text.Parsing.RuleParser
 1038         {
 1039             public ArgInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1040             {
 1041                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1042                 SetValueTypeName(ToUtf32("Instruction*"));
 1043             }
 1044             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1045             {
 1046                 parsingData->PushContext(Id(), new Context());
 1047                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1048                 UniquePtr<Object> context_value = stack.Pop();
 1049                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1050             }
 1051             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1052             {
 1053                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1054                 if (matched)
 1055                 {
 1056                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1057                 }
 1058                 parsingData->PopContext(Id());
 1059             }
 1060             public override void Link()
 1061             {
 1062                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1063                 a0ActionParser->SetAction(A0Action);
 1064                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 1065                 typeNonterminalParser->SetPre(Pretype);
 1066                 typeNonterminalParser->SetPost(Posttype);
 1067                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 1068                 argNonterminalParser->SetPre(Prearg);
 1069                 argNonterminalParser->SetPost(Postarg);
 1070             }
 1071             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1072             {
 1073                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1074                 context->value = new ArgInstruction(context->fromarg, span.lineNumber);
 1075             }
 1076             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1077             {
 1078                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1079                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1080             }
 1081             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1082             {
 1083                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1084                 if (matched)
 1085                 {
 1086                     UniquePtr<Object> fromtype_value = stack.Pop();
 1087                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 1088                 }
 1089             }
 1090             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1091             {
 1092                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1093                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1094                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 1095             }
 1096             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1097             {
 1098                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1099                 if (matched)
 1100                 {
 1101                     UniquePtr<Object> fromarg_value = stack.Pop();
 1102                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 1103                 }
 1104             }
 1105             public class Context : System.Text.Parsing.Context
 1106             {
 1107                 public Context() : context(), value(), fromtype(), fromarg()
 1108                 {
 1109                 }
 1110                 public cmsx.intermediate.Context* context;
 1111                 public Instruction* value;
 1112                 public Type* fromtype;
 1113                 public Value* fromarg;
 1114             }
 1115         }
 1116 
 1117         public class JumpInstructionRule : System.Text.Parsing.RuleParser
 1118         {
 1119             public JumpInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1120             {
 1121                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1122                 SetValueTypeName(ToUtf32("Instruction*"));
 1123             }
 1124             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1125             {
 1126                 parsingData->PushContext(Id(), new Context());
 1127                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1128                 UniquePtr<Object> context_value = stack.Pop();
 1129                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1130             }
 1131             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1132             {
 1133                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1134                 if (matched)
 1135                 {
 1136                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1137                 }
 1138                 parsingData->PopContext(Id());
 1139             }
 1140             public override void Link()
 1141             {
 1142                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1143                 a0ActionParser->SetAction(A0Action);
 1144                 NonterminalParser* targetNonterminalParser = GetNonterminal(ToUtf32("target"));
 1145                 targetNonterminalParser->SetPost(Posttarget);
 1146             }
 1147             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1148             {
 1149                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1150                 context->value = new JumpInstruction(context->fromtarget, span.lineNumber);
 1151             }
 1152             public void Posttarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1153             {
 1154                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1155                 if (matched)
 1156                 {
 1157                     UniquePtr<Object> fromtarget_value = stack.Pop();
 1158                     context->fromtarget = *cast<ValueObject<uint>*>(fromtarget_value.Get());
 1159                 }
 1160             }
 1161             public class Context : System.Text.Parsing.Context
 1162             {
 1163                 public Context() : context(), value(), fromtarget()
 1164                 {
 1165                 }
 1166                 public cmsx.intermediate.Context* context;
 1167                 public Instruction* value;
 1168                 public uint fromtarget;
 1169             }
 1170         }
 1171 
 1172         public class BranchInstructionRule : System.Text.Parsing.RuleParser
 1173         {
 1174             public BranchInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1175             {
 1176                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1177                 SetValueTypeName(ToUtf32("Instruction*"));
 1178             }
 1179             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1180             {
 1181                 parsingData->PushContext(Id(), new Context());
 1182                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1183                 UniquePtr<Object> context_value = stack.Pop();
 1184                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1185             }
 1186             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1187             {
 1188                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1189                 if (matched)
 1190                 {
 1191                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1192                 }
 1193                 parsingData->PopContext(Id());
 1194             }
 1195             public override void Link()
 1196             {
 1197                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1198                 a0ActionParser->SetAction(A0Action);
 1199                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 1200                 typeNonterminalParser->SetPre(Pretype);
 1201                 typeNonterminalParser->SetPost(Posttype);
 1202                 NonterminalParser* condNonterminalParser = GetNonterminal(ToUtf32("cond"));
 1203                 condNonterminalParser->SetPre(Precond);
 1204                 condNonterminalParser->SetPost(Postcond);
 1205                 NonterminalParser* trueTargetNonterminalParser = GetNonterminal(ToUtf32("trueTarget"));
 1206                 trueTargetNonterminalParser->SetPost(PosttrueTarget);
 1207                 NonterminalParser* falseTargetNonterminalParser = GetNonterminal(ToUtf32("falseTarget"));
 1208                 falseTargetNonterminalParser->SetPost(PostfalseTarget);
 1209             }
 1210             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1211             {
 1212                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1213                 context->value = new BranchInstruction(context->fromcond, context->fromtrueTarget, context->fromfalseTarget, span.lineNumber);
 1214             }
 1215             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1216             {
 1217                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1218                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1219             }
 1220             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1221             {
 1222                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1223                 if (matched)
 1224                 {
 1225                     UniquePtr<Object> fromtype_value = stack.Pop();
 1226                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 1227                 }
 1228             }
 1229             public void Precond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1230             {
 1231                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1232                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1233                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 1234             }
 1235             public void Postcond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1236             {
 1237                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1238                 if (matched)
 1239                 {
 1240                     UniquePtr<Object> fromcond_value = stack.Pop();
 1241                     context->fromcond = *cast<ValueObject<Value*>*>(fromcond_value.Get());
 1242                 }
 1243             }
 1244             public void PosttrueTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1245             {
 1246                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1247                 if (matched)
 1248                 {
 1249                     UniquePtr<Object> fromtrueTarget_value = stack.Pop();
 1250                     context->fromtrueTarget = *cast<ValueObject<uint>*>(fromtrueTarget_value.Get());
 1251                 }
 1252             }
 1253             public void PostfalseTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1254             {
 1255                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1256                 if (matched)
 1257                 {
 1258                     UniquePtr<Object> fromfalseTarget_value = stack.Pop();
 1259                     context->fromfalseTarget = *cast<ValueObject<uint>*>(fromfalseTarget_value.Get());
 1260                 }
 1261             }
 1262             public class Context : System.Text.Parsing.Context
 1263             {
 1264                 public Context() : context(), value(), fromtype(), fromcond(), fromtrueTarget(), fromfalseTarget()
 1265                 {
 1266                 }
 1267                 public cmsx.intermediate.Context* context;
 1268                 public Instruction* value;
 1269                 public Type* fromtype;
 1270                 public Value* fromcond;
 1271                 public uint fromtrueTarget;
 1272                 public uint fromfalseTarget;
 1273             }
 1274         }
 1275 
 1276         public class ProcedureCallInstructionRule : System.Text.Parsing.RuleParser
 1277         {
 1278             public ProcedureCallInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1279             {
 1280                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1281                 SetValueTypeName(ToUtf32("Instruction*"));
 1282             }
 1283             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1284             {
 1285                 parsingData->PushContext(Id(), new Context());
 1286                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1287                 UniquePtr<Object> context_value = stack.Pop();
 1288                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1289             }
 1290             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1291             {
 1292                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1293                 if (matched)
 1294                 {
 1295                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1296                 }
 1297                 parsingData->PopContext(Id());
 1298             }
 1299             public override void Link()
 1300             {
 1301                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1302                 a0ActionParser->SetAction(A0Action);
 1303                 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
 1304                 functionTypeNonterminalParser->SetPre(PrefunctionType);
 1305                 functionTypeNonterminalParser->SetPost(PostfunctionType);
 1306                 NonterminalParser* calleeNonterminalParser = GetNonterminal(ToUtf32("callee"));
 1307                 calleeNonterminalParser->SetPre(Precallee);
 1308                 calleeNonterminalParser->SetPost(Postcallee);
 1309             }
 1310             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1311             {
 1312                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1313                 context->value = new ProcedureCallInstruction(context->fromcallee, span.lineNumber);
 1314             }
 1315             public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1316             {
 1317                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1318                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1319             }
 1320             public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1321             {
 1322                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1323                 if (matched)
 1324                 {
 1325                     UniquePtr<Object> fromfunctionType_value = stack.Pop();
 1326                     context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
 1327                 }
 1328             }
 1329             public void Precallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1330             {
 1331                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1332                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1333                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromfunctionType)));
 1334             }
 1335             public void Postcallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1336             {
 1337                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1338                 if (matched)
 1339                 {
 1340                     UniquePtr<Object> fromcallee_value = stack.Pop();
 1341                     context->fromcallee = *cast<ValueObject<Value*>*>(fromcallee_value.Get());
 1342                 }
 1343             }
 1344             public class Context : System.Text.Parsing.Context
 1345             {
 1346                 public Context() : context(), value(), fromfunctionType(), fromcallee()
 1347                 {
 1348                 }
 1349                 public cmsx.intermediate.Context* context;
 1350                 public Instruction* value;
 1351                 public Type* fromfunctionType;
 1352                 public Value* fromcallee;
 1353             }
 1354         }
 1355 
 1356         public class RetInstructionRule : System.Text.Parsing.RuleParser
 1357         {
 1358             public RetInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1359             {
 1360                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1361                 SetValueTypeName(ToUtf32("Instruction*"));
 1362             }
 1363             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1364             {
 1365                 parsingData->PushContext(Id(), new Context());
 1366                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1367                 UniquePtr<Object> context_value = stack.Pop();
 1368                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1369             }
 1370             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1371             {
 1372                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1373                 if (matched)
 1374                 {
 1375                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1376                 }
 1377                 parsingData->PopContext(Id());
 1378             }
 1379             public override void Link()
 1380             {
 1381                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1382                 a0ActionParser->SetAction(A0Action);
 1383                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 1384                 a1ActionParser->SetAction(A1Action);
 1385                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 1386                 typeNonterminalParser->SetPre(Pretype);
 1387                 typeNonterminalParser->SetPost(Posttype);
 1388                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 1389                 valNonterminalParser->SetPre(Preval);
 1390                 valNonterminalParser->SetPost(Postval);
 1391             }
 1392             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1393             {
 1394                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1395                 context->value = new RetInstruction(null, span.lineNumber);
 1396             }
 1397             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1398             {
 1399                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1400                 context->value = new RetInstruction(context->fromval, span.lineNumber);
 1401             }
 1402             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1403             {
 1404                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1405                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1406             }
 1407             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1408             {
 1409                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1410                 if (matched)
 1411                 {
 1412                     UniquePtr<Object> fromtype_value = stack.Pop();
 1413                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 1414                 }
 1415             }
 1416             public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1417             {
 1418                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1419                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1420                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 1421             }
 1422             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1423             {
 1424                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1425                 if (matched)
 1426                 {
 1427                     UniquePtr<Object> fromval_value = stack.Pop();
 1428                     context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
 1429                 }
 1430             }
 1431             public class Context : System.Text.Parsing.Context
 1432             {
 1433                 public Context() : context(), value(), fromtype(), fromval()
 1434                 {
 1435                 }
 1436                 public cmsx.intermediate.Context* context;
 1437                 public Instruction* value;
 1438                 public Type* fromtype;
 1439                 public Value* fromval;
 1440             }
 1441         }
 1442 
 1443         public class SwitchInstructionRule : System.Text.Parsing.RuleParser
 1444         {
 1445             public SwitchInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1446             {
 1447                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1448                 SetValueTypeName(ToUtf32("SwitchInstruction*"));
 1449             }
 1450             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1451             {
 1452                 parsingData->PushContext(Id(), new Context());
 1453                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1454                 UniquePtr<Object> context_value = stack.Pop();
 1455                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1456             }
 1457             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1458             {
 1459                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1460                 if (matched)
 1461                 {
 1462                     stack.Push(UniquePtr<Object>(new ValueObject<SwitchInstruction*>(context->value)));
 1463                 }
 1464                 parsingData->PopContext(Id());
 1465             }
 1466             public override void Link()
 1467             {
 1468                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1469                 a0ActionParser->SetAction(A0Action);
 1470                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 1471                 a1ActionParser->SetAction(A1Action);
 1472                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 1473                 typeNonterminalParser->SetPre(Pretype);
 1474                 typeNonterminalParser->SetPost(Posttype);
 1475                 NonterminalParser* condNonterminalParser = GetNonterminal(ToUtf32("cond"));
 1476                 condNonterminalParser->SetPre(Precond);
 1477                 condNonterminalParser->SetPost(Postcond);
 1478                 NonterminalParser* defaultTargetNonterminalParser = GetNonterminal(ToUtf32("defaultTarget"));
 1479                 defaultTargetNonterminalParser->SetPost(PostdefaultTarget);
 1480                 NonterminalParser* caseTypeNonterminalParser = GetNonterminal(ToUtf32("caseType"));
 1481                 caseTypeNonterminalParser->SetPre(PrecaseType);
 1482                 caseTypeNonterminalParser->SetPost(PostcaseType);
 1483                 NonterminalParser* caseValueNonterminalParser = GetNonterminal(ToUtf32("caseValue"));
 1484                 caseValueNonterminalParser->SetPre(PrecaseValue);
 1485                 caseValueNonterminalParser->SetPost(PostcaseValue);
 1486                 NonterminalParser* caseTargetNonterminalParser = GetNonterminal(ToUtf32("caseTarget"));
 1487                 caseTargetNonterminalParser->SetPost(PostcaseTarget);
 1488             }
 1489             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1490             {
 1491                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1492                 context->value = new SwitchInstruction(context->fromcond, context->fromdefaultTarget, span.lineNumber);
 1493             }
 1494             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1495             {
 1496                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1497                 context->value->AddCase(context->fromcaseValue, context->fromcaseTarget);
 1498             }
 1499             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1500             {
 1501                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1502                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1503             }
 1504             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1505             {
 1506                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1507                 if (matched)
 1508                 {
 1509                     UniquePtr<Object> fromtype_value = stack.Pop();
 1510                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 1511                 }
 1512             }
 1513             public void Precond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1514             {
 1515                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1516                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1517                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 1518             }
 1519             public void Postcond(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1520             {
 1521                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1522                 if (matched)
 1523                 {
 1524                     UniquePtr<Object> fromcond_value = stack.Pop();
 1525                     context->fromcond = *cast<ValueObject<Value*>*>(fromcond_value.Get());
 1526                 }
 1527             }
 1528             public void PostdefaultTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1529             {
 1530                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1531                 if (matched)
 1532                 {
 1533                     UniquePtr<Object> fromdefaultTarget_value = stack.Pop();
 1534                     context->fromdefaultTarget = *cast<ValueObject<uint>*>(fromdefaultTarget_value.Get());
 1535                 }
 1536             }
 1537             public void PrecaseType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1538             {
 1539                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1540                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1541             }
 1542             public void PostcaseType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1543             {
 1544                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1545                 if (matched)
 1546                 {
 1547                     UniquePtr<Object> fromcaseType_value = stack.Pop();
 1548                     context->fromcaseType = *cast<ValueObject<Type*>*>(fromcaseType_value.Get());
 1549                 }
 1550             }
 1551             public void PrecaseValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1552             {
 1553                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1554                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1555                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromcaseType)));
 1556             }
 1557             public void PostcaseValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1558             {
 1559                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1560                 if (matched)
 1561                 {
 1562                     UniquePtr<Object> fromcaseValue_value = stack.Pop();
 1563                     context->fromcaseValue = *cast<ValueObject<Value*>*>(fromcaseValue_value.Get());
 1564                 }
 1565             }
 1566             public void PostcaseTarget(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1567             {
 1568                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1569                 if (matched)
 1570                 {
 1571                     UniquePtr<Object> fromcaseTarget_value = stack.Pop();
 1572                     context->fromcaseTarget = *cast<ValueObject<uint>*>(fromcaseTarget_value.Get());
 1573                 }
 1574             }
 1575             public class Context : System.Text.Parsing.Context
 1576             {
 1577                 public Context() : context(), value(), fromtype(), fromcond(), fromdefaultTarget(), fromcaseType(), fromcaseValue(), fromcaseTarget()
 1578                 {
 1579                 }
 1580                 public cmsx.intermediate.Context* context;
 1581                 public SwitchInstruction* value;
 1582                 public Type* fromtype;
 1583                 public Value* fromcond;
 1584                 public uint fromdefaultTarget;
 1585                 public Type* fromcaseType;
 1586                 public Value* fromcaseValue;
 1587                 public uint fromcaseTarget;
 1588             }
 1589         }
 1590 
 1591         public class NoOperationInstructionRule : System.Text.Parsing.RuleParser
 1592         {
 1593             public NoOperationInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1594             {
 1595                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1596                 SetValueTypeName(ToUtf32("Instruction*"));
 1597             }
 1598             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1599             {
 1600                 parsingData->PushContext(Id(), new Context());
 1601                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1602                 UniquePtr<Object> context_value = stack.Pop();
 1603                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1604             }
 1605             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1606             {
 1607                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1608                 if (matched)
 1609                 {
 1610                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1611                 }
 1612                 parsingData->PopContext(Id());
 1613             }
 1614             public override void Link()
 1615             {
 1616                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1617                 a0ActionParser->SetAction(A0Action);
 1618             }
 1619             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1620             {
 1621                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1622                 context->value = new NoOperationInstruction(span.lineNumber);
 1623             }
 1624             public class Context : System.Text.Parsing.Context
 1625             {
 1626                 public Context() : context(), value()
 1627                 {
 1628                 }
 1629                 public cmsx.intermediate.Context* context;
 1630                 public Instruction* value;
 1631             }
 1632         }
 1633 
 1634         public class SaveInstructionRule : System.Text.Parsing.RuleParser
 1635         {
 1636             public SaveInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1637             {
 1638                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1639                 SetValueTypeName(ToUtf32("Instruction*"));
 1640             }
 1641             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1642             {
 1643                 parsingData->PushContext(Id(), new Context());
 1644                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1645                 UniquePtr<Object> context_value = stack.Pop();
 1646                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1647             }
 1648             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1649             {
 1650                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1651                 if (matched)
 1652                 {
 1653                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1654                 }
 1655                 parsingData->PopContext(Id());
 1656             }
 1657             public override void Link()
 1658             {
 1659                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1660                 a0ActionParser->SetAction(A0Action);
 1661             }
 1662             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1663             {
 1664                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1665                 context->value = new SaveInstruction(span.lineNumber);
 1666             }
 1667             public class Context : System.Text.Parsing.Context
 1668             {
 1669                 public Context() : context(), value()
 1670                 {
 1671                 }
 1672                 public cmsx.intermediate.Context* context;
 1673                 public Instruction* value;
 1674             }
 1675         }
 1676 
 1677         public class ValueInstructionRule : System.Text.Parsing.RuleParser
 1678         {
 1679             public ValueInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1680             {
 1681                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1682                 SetValueTypeName(ToUtf32("Instruction*"));
 1683             }
 1684             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1685             {
 1686                 parsingData->PushContext(Id(), new Context());
 1687                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1688                 UniquePtr<Object> context_value = stack.Pop();
 1689                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1690             }
 1691             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1692             {
 1693                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1694                 if (matched)
 1695                 {
 1696                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1697                 }
 1698                 parsingData->PopContext(Id());
 1699             }
 1700             public override void Link()
 1701             {
 1702                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1703                 a0ActionParser->SetAction(A0Action);
 1704                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 1705                 typeNonterminalParser->SetPre(Pretype);
 1706                 typeNonterminalParser->SetPost(Posttype);
 1707                 NonterminalParser* resultNonterminalParser = GetNonterminal(ToUtf32("result"));
 1708                 resultNonterminalParser->SetPre(Preresult);
 1709                 resultNonterminalParser->SetPost(Postresult);
 1710                 NonterminalParser* operationNonterminalParser = GetNonterminal(ToUtf32("Operation"));
 1711                 operationNonterminalParser->SetPre(PreOperation);
 1712                 operationNonterminalParser->SetPost(PostOperation);
 1713             }
 1714             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1715             {
 1716                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1717                 context->value = context->fromOperation;
 1718             }
 1719             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1720             {
 1721                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1722                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1723             }
 1724             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1725             {
 1726                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1727                 if (matched)
 1728                 {
 1729                     UniquePtr<Object> fromtype_value = stack.Pop();
 1730                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 1731                 }
 1732             }
 1733             public void Preresult(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1734             {
 1735                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1736                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1737                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 1738             }
 1739             public void Postresult(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1740             {
 1741                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1742                 if (matched)
 1743                 {
 1744                     UniquePtr<Object> fromresult_value = stack.Pop();
 1745                     context->fromresult = *cast<ValueObject<Value*>*>(fromresult_value.Get());
 1746                 }
 1747             }
 1748             public void PreOperation(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1749             {
 1750                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1751                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1752                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->fromresult)));
 1753             }
 1754             public void PostOperation(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1755             {
 1756                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1757                 if (matched)
 1758                 {
 1759                     UniquePtr<Object> fromOperation_value = stack.Pop();
 1760                     context->fromOperation = *cast<ValueObject<Instruction*>*>(fromOperation_value.Get());
 1761                 }
 1762             }
 1763             public class Context : System.Text.Parsing.Context
 1764             {
 1765                 public Context() : context(), value(), fromtype(), fromresult(), fromOperation()
 1766                 {
 1767                 }
 1768                 public cmsx.intermediate.Context* context;
 1769                 public Instruction* value;
 1770                 public Type* fromtype;
 1771                 public Value* fromresult;
 1772                 public Instruction* fromOperation;
 1773             }
 1774         }
 1775 
 1776         public class OperationRule : System.Text.Parsing.RuleParser
 1777         {
 1778             public OperationRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 1779             {
 1780                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 1781                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 1782                 SetValueTypeName(ToUtf32("Instruction*"));
 1783             }
 1784             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1785             {
 1786                 parsingData->PushContext(Id(), new Context());
 1787                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1788                 UniquePtr<Object> result_value = stack.Pop();
 1789                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 1790                 UniquePtr<Object> context_value = stack.Pop();
 1791                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 1792             }
 1793             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1794             {
 1795                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1796                 if (matched)
 1797                 {
 1798                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 1799                 }
 1800                 parsingData->PopContext(Id());
 1801             }
 1802             public override void Link()
 1803             {
 1804                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 1805                 a0ActionParser->SetAction(A0Action);
 1806                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 1807                 a1ActionParser->SetAction(A1Action);
 1808                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 1809                 a2ActionParser->SetAction(A2Action);
 1810                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 1811                 a3ActionParser->SetAction(A3Action);
 1812                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 1813                 a4ActionParser->SetAction(A4Action);
 1814                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 1815                 a5ActionParser->SetAction(A5Action);
 1816                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 1817                 a6ActionParser->SetAction(A6Action);
 1818                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 1819                 a7ActionParser->SetAction(A7Action);
 1820                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 1821                 a8ActionParser->SetAction(A8Action);
 1822                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 1823                 a9ActionParser->SetAction(A9Action);
 1824                 NonterminalParser* unaryInstructionNonterminalParser = GetNonterminal(ToUtf32("UnaryInstruction"));
 1825                 unaryInstructionNonterminalParser->SetPre(PreUnaryInstruction);
 1826                 unaryInstructionNonterminalParser->SetPost(PostUnaryInstruction);
 1827                 NonterminalParser* binaryInstructionNonterminalParser = GetNonterminal(ToUtf32("BinaryInstruction"));
 1828                 binaryInstructionNonterminalParser->SetPre(PreBinaryInstruction);
 1829                 binaryInstructionNonterminalParser->SetPost(PostBinaryInstruction);
 1830                 NonterminalParser* paramInstructionNonterminalParser = GetNonterminal(ToUtf32("ParamInstruction"));
 1831                 paramInstructionNonterminalParser->SetPre(PreParamInstruction);
 1832                 paramInstructionNonterminalParser->SetPost(PostParamInstruction);
 1833                 NonterminalParser* localInstructionNonterminalParser = GetNonterminal(ToUtf32("LocalInstruction"));
 1834                 localInstructionNonterminalParser->SetPre(PreLocalInstruction);
 1835                 localInstructionNonterminalParser->SetPost(PostLocalInstruction);
 1836                 NonterminalParser* loadInstructionNonterminalParser = GetNonterminal(ToUtf32("LoadInstruction"));
 1837                 loadInstructionNonterminalParser->SetPre(PreLoadInstruction);
 1838                 loadInstructionNonterminalParser->SetPost(PostLoadInstruction);
 1839                 NonterminalParser* elemAddrInstructionNonterminalParser = GetNonterminal(ToUtf32("ElemAddrInstruction"));
 1840                 elemAddrInstructionNonterminalParser->SetPre(PreElemAddrInstruction);
 1841                 elemAddrInstructionNonterminalParser->SetPost(PostElemAddrInstruction);
 1842                 NonterminalParser* ptrOffsetInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrOffsetInstruction"));
 1843                 ptrOffsetInstructionNonterminalParser->SetPre(PrePtrOffsetInstruction);
 1844                 ptrOffsetInstructionNonterminalParser->SetPost(PostPtrOffsetInstruction);
 1845                 NonterminalParser* ptrDiffInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrDiffInstruction"));
 1846                 ptrDiffInstructionNonterminalParser->SetPre(PrePtrDiffInstruction);
 1847                 ptrDiffInstructionNonterminalParser->SetPost(PostPtrDiffInstruction);
 1848                 NonterminalParser* functionCallInstructionNonterminalParser = GetNonterminal(ToUtf32("FunctionCallInstruction"));
 1849                 functionCallInstructionNonterminalParser->SetPre(PreFunctionCallInstruction);
 1850                 functionCallInstructionNonterminalParser->SetPost(PostFunctionCallInstruction);
 1851                 NonterminalParser* trapInstructionNonterminalParser = GetNonterminal(ToUtf32("TrapInstruction"));
 1852                 trapInstructionNonterminalParser->SetPre(PreTrapInstruction);
 1853                 trapInstructionNonterminalParser->SetPost(PostTrapInstruction);
 1854             }
 1855             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1856             {
 1857                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1858                 context->value = context->fromUnaryInstruction;
 1859             }
 1860             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1861             {
 1862                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1863                 context->value = context->fromBinaryInstruction;
 1864             }
 1865             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1866             {
 1867                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1868                 context->value = context->fromParamInstruction;
 1869             }
 1870             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1871             {
 1872                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1873                 context->value = context->fromLocalInstruction;
 1874             }
 1875             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1876             {
 1877                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1878                 context->value = context->fromLoadInstruction;
 1879             }
 1880             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1881             {
 1882                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1883                 context->value = context->fromElemAddrInstruction;
 1884             }
 1885             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1886             {
 1887                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1888                 context->value = context->fromPtrOffsetInstruction;
 1889             }
 1890             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1891             {
 1892                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1893                 context->value = context->fromPtrDiffInstruction;
 1894             }
 1895             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1896             {
 1897                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1898                 context->value = context->fromFunctionCallInstruction;
 1899             }
 1900             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 1901             {
 1902                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1903                 context->value = context->fromTrapInstruction;
 1904             }
 1905             public void PreUnaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1906             {
 1907                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1908                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1909                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1910             }
 1911             public void PostUnaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1912             {
 1913                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1914                 if (matched)
 1915                 {
 1916                     UniquePtr<Object> fromUnaryInstruction_value = stack.Pop();
 1917                     context->fromUnaryInstruction = *cast<ValueObject<Instruction*>*>(fromUnaryInstruction_value.Get());
 1918                 }
 1919             }
 1920             public void PreBinaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1921             {
 1922                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1923                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1924                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1925             }
 1926             public void PostBinaryInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1927             {
 1928                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1929                 if (matched)
 1930                 {
 1931                     UniquePtr<Object> fromBinaryInstruction_value = stack.Pop();
 1932                     context->fromBinaryInstruction = *cast<ValueObject<Instruction*>*>(fromBinaryInstruction_value.Get());
 1933                 }
 1934             }
 1935             public void PreParamInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1936             {
 1937                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1938                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1939                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1940             }
 1941             public void PostParamInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1942             {
 1943                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1944                 if (matched)
 1945                 {
 1946                     UniquePtr<Object> fromParamInstruction_value = stack.Pop();
 1947                     context->fromParamInstruction = *cast<ValueObject<Instruction*>*>(fromParamInstruction_value.Get());
 1948                 }
 1949             }
 1950             public void PreLocalInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1951             {
 1952                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1953                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1954                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1955             }
 1956             public void PostLocalInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1957             {
 1958                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1959                 if (matched)
 1960                 {
 1961                     UniquePtr<Object> fromLocalInstruction_value = stack.Pop();
 1962                     context->fromLocalInstruction = *cast<ValueObject<Instruction*>*>(fromLocalInstruction_value.Get());
 1963                 }
 1964             }
 1965             public void PreLoadInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1966             {
 1967                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1968                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1969                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1970             }
 1971             public void PostLoadInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1972             {
 1973                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1974                 if (matched)
 1975                 {
 1976                     UniquePtr<Object> fromLoadInstruction_value = stack.Pop();
 1977                     context->fromLoadInstruction = *cast<ValueObject<Instruction*>*>(fromLoadInstruction_value.Get());
 1978                 }
 1979             }
 1980             public void PreElemAddrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1981             {
 1982                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1983                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1984                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 1985             }
 1986             public void PostElemAddrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 1987             {
 1988                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1989                 if (matched)
 1990                 {
 1991                     UniquePtr<Object> fromElemAddrInstruction_value = stack.Pop();
 1992                     context->fromElemAddrInstruction = *cast<ValueObject<Instruction*>*>(fromElemAddrInstruction_value.Get());
 1993                 }
 1994             }
 1995             public void PrePtrOffsetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 1996             {
 1997                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 1998                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 1999                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2000             }
 2001             public void PostPtrOffsetInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2002             {
 2003                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2004                 if (matched)
 2005                 {
 2006                     UniquePtr<Object> fromPtrOffsetInstruction_value = stack.Pop();
 2007                     context->fromPtrOffsetInstruction = *cast<ValueObject<Instruction*>*>(fromPtrOffsetInstruction_value.Get());
 2008                 }
 2009             }
 2010             public void PrePtrDiffInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2011             {
 2012                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2013                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2014                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2015             }
 2016             public void PostPtrDiffInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2017             {
 2018                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2019                 if (matched)
 2020                 {
 2021                     UniquePtr<Object> fromPtrDiffInstruction_value = stack.Pop();
 2022                     context->fromPtrDiffInstruction = *cast<ValueObject<Instruction*>*>(fromPtrDiffInstruction_value.Get());
 2023                 }
 2024             }
 2025             public void PreFunctionCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2026             {
 2027                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2028                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2029                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2030             }
 2031             public void PostFunctionCallInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2032             {
 2033                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2034                 if (matched)
 2035                 {
 2036                     UniquePtr<Object> fromFunctionCallInstruction_value = stack.Pop();
 2037                     context->fromFunctionCallInstruction = *cast<ValueObject<Instruction*>*>(fromFunctionCallInstruction_value.Get());
 2038                 }
 2039             }
 2040             public void PreTrapInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2041             {
 2042                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2043                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2044                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2045             }
 2046             public void PostTrapInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2047             {
 2048                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2049                 if (matched)
 2050                 {
 2051                     UniquePtr<Object> fromTrapInstruction_value = stack.Pop();
 2052                     context->fromTrapInstruction = *cast<ValueObject<Instruction*>*>(fromTrapInstruction_value.Get());
 2053                 }
 2054             }
 2055             public class Context : System.Text.Parsing.Context
 2056             {
 2057                 public Context() : context(), result(), value(), fromUnaryInstruction(), fromBinaryInstruction(), fromParamInstruction(), fromLocalInstruction(), fromLoadInstruction(), fromElemAddrInstruction(), fromPtrOffsetInstruction(), fromPtrDiffInstruction(), fromFunctionCallInstruction(), fromTrapInstruction()
 2058                 {
 2059                 }
 2060                 public cmsx.intermediate.Context* context;
 2061                 public Value* result;
 2062                 public Instruction* value;
 2063                 public Instruction* fromUnaryInstruction;
 2064                 public Instruction* fromBinaryInstruction;
 2065                 public Instruction* fromParamInstruction;
 2066                 public Instruction* fromLocalInstruction;
 2067                 public Instruction* fromLoadInstruction;
 2068                 public Instruction* fromElemAddrInstruction;
 2069                 public Instruction* fromPtrOffsetInstruction;
 2070                 public Instruction* fromPtrDiffInstruction;
 2071                 public Instruction* fromFunctionCallInstruction;
 2072                 public Instruction* fromTrapInstruction;
 2073             }
 2074         }
 2075 
 2076         public class UnaryInstructionRule : System.Text.Parsing.RuleParser
 2077         {
 2078             public UnaryInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2079             {
 2080                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2081                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2082                 SetValueTypeName(ToUtf32("Instruction*"));
 2083             }
 2084             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2085             {
 2086                 parsingData->PushContext(Id(), new Context());
 2087                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2088                 UniquePtr<Object> result_value = stack.Pop();
 2089                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2090                 UniquePtr<Object> context_value = stack.Pop();
 2091                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2092             }
 2093             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2094             {
 2095                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2096                 if (matched)
 2097                 {
 2098                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2099                 }
 2100                 parsingData->PopContext(Id());
 2101             }
 2102             public override void Link()
 2103             {
 2104                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2105                 a0ActionParser->SetAction(A0Action);
 2106                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 2107                 a1ActionParser->SetAction(A1Action);
 2108                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 2109                 a2ActionParser->SetAction(A2Action);
 2110                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 2111                 a3ActionParser->SetAction(A3Action);
 2112                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 2113                 a4ActionParser->SetAction(A4Action);
 2114                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 2115                 a5ActionParser->SetAction(A5Action);
 2116                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 2117                 a6ActionParser->SetAction(A6Action);
 2118                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 2119                 a7ActionParser->SetAction(A7Action);
 2120                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 2121                 a8ActionParser->SetAction(A8Action);
 2122                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 2123                 a9ActionParser->SetAction(A9Action);
 2124                 NonterminalParser* notInstructionNonterminalParser = GetNonterminal(ToUtf32("NotInstruction"));
 2125                 notInstructionNonterminalParser->SetPre(PreNotInstruction);
 2126                 notInstructionNonterminalParser->SetPost(PostNotInstruction);
 2127                 NonterminalParser* negInstructionNonterminalParser = GetNonterminal(ToUtf32("NegInstruction"));
 2128                 negInstructionNonterminalParser->SetPre(PreNegInstruction);
 2129                 negInstructionNonterminalParser->SetPost(PostNegInstruction);
 2130                 NonterminalParser* signExtendInstructionNonterminalParser = GetNonterminal(ToUtf32("SignExtendInstruction"));
 2131                 signExtendInstructionNonterminalParser->SetPre(PreSignExtendInstruction);
 2132                 signExtendInstructionNonterminalParser->SetPost(PostSignExtendInstruction);
 2133                 NonterminalParser* zeroExtendInstructionNonterminalParser = GetNonterminal(ToUtf32("ZeroExtendInstruction"));
 2134                 zeroExtendInstructionNonterminalParser->SetPre(PreZeroExtendInstruction);
 2135                 zeroExtendInstructionNonterminalParser->SetPost(PostZeroExtendInstruction);
 2136                 NonterminalParser* truncateInstructionNonterminalParser = GetNonterminal(ToUtf32("TruncateInstruction"));
 2137                 truncateInstructionNonterminalParser->SetPre(PreTruncateInstruction);
 2138                 truncateInstructionNonterminalParser->SetPost(PostTruncateInstruction);
 2139                 NonterminalParser* bitCastInstructionNonterminalParser = GetNonterminal(ToUtf32("BitCastInstruction"));
 2140                 bitCastInstructionNonterminalParser->SetPre(PreBitCastInstruction);
 2141                 bitCastInstructionNonterminalParser->SetPost(PostBitCastInstruction);
 2142                 NonterminalParser* intToFloatInstructionNonterminalParser = GetNonterminal(ToUtf32("IntToFloatInstruction"));
 2143                 intToFloatInstructionNonterminalParser->SetPre(PreIntToFloatInstruction);
 2144                 intToFloatInstructionNonterminalParser->SetPost(PostIntToFloatInstruction);
 2145                 NonterminalParser* floatToIntInstructionNonterminalParser = GetNonterminal(ToUtf32("FloatToIntInstruction"));
 2146                 floatToIntInstructionNonterminalParser->SetPre(PreFloatToIntInstruction);
 2147                 floatToIntInstructionNonterminalParser->SetPost(PostFloatToIntInstruction);
 2148                 NonterminalParser* intToPtrInstructionNonterminalParser = GetNonterminal(ToUtf32("IntToPtrInstruction"));
 2149                 intToPtrInstructionNonterminalParser->SetPre(PreIntToPtrInstruction);
 2150                 intToPtrInstructionNonterminalParser->SetPost(PostIntToPtrInstruction);
 2151                 NonterminalParser* ptrToIntInstructionNonterminalParser = GetNonterminal(ToUtf32("PtrToIntInstruction"));
 2152                 ptrToIntInstructionNonterminalParser->SetPre(PrePtrToIntInstruction);
 2153                 ptrToIntInstructionNonterminalParser->SetPost(PostPtrToIntInstruction);
 2154             }
 2155             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2156             {
 2157                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2158                 context->value = context->fromNotInstruction;
 2159             }
 2160             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2161             {
 2162                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2163                 context->value = context->fromNegInstruction;
 2164             }
 2165             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2166             {
 2167                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2168                 context->value = context->fromSignExtendInstruction;
 2169             }
 2170             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2171             {
 2172                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2173                 context->value = context->fromZeroExtendInstruction;
 2174             }
 2175             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2176             {
 2177                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2178                 context->value = context->fromTruncateInstruction;
 2179             }
 2180             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2181             {
 2182                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2183                 context->value = context->fromBitCastInstruction;
 2184             }
 2185             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2186             {
 2187                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2188                 context->value = context->fromIntToFloatInstruction;
 2189             }
 2190             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2191             {
 2192                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2193                 context->value = context->fromFloatToIntInstruction;
 2194             }
 2195             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2196             {
 2197                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2198                 context->value = context->fromIntToPtrInstruction;
 2199             }
 2200             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2201             {
 2202                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2203                 context->value = context->fromPtrToIntInstruction;
 2204             }
 2205             public void PreNotInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2206             {
 2207                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2208                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2209                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2210             }
 2211             public void PostNotInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2212             {
 2213                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2214                 if (matched)
 2215                 {
 2216                     UniquePtr<Object> fromNotInstruction_value = stack.Pop();
 2217                     context->fromNotInstruction = *cast<ValueObject<Instruction*>*>(fromNotInstruction_value.Get());
 2218                 }
 2219             }
 2220             public void PreNegInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2221             {
 2222                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2223                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2224                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2225             }
 2226             public void PostNegInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2227             {
 2228                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2229                 if (matched)
 2230                 {
 2231                     UniquePtr<Object> fromNegInstruction_value = stack.Pop();
 2232                     context->fromNegInstruction = *cast<ValueObject<Instruction*>*>(fromNegInstruction_value.Get());
 2233                 }
 2234             }
 2235             public void PreSignExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2236             {
 2237                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2238                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2239                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2240             }
 2241             public void PostSignExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2242             {
 2243                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2244                 if (matched)
 2245                 {
 2246                     UniquePtr<Object> fromSignExtendInstruction_value = stack.Pop();
 2247                     context->fromSignExtendInstruction = *cast<ValueObject<Instruction*>*>(fromSignExtendInstruction_value.Get());
 2248                 }
 2249             }
 2250             public void PreZeroExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2251             {
 2252                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2253                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2254                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2255             }
 2256             public void PostZeroExtendInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2257             {
 2258                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2259                 if (matched)
 2260                 {
 2261                     UniquePtr<Object> fromZeroExtendInstruction_value = stack.Pop();
 2262                     context->fromZeroExtendInstruction = *cast<ValueObject<Instruction*>*>(fromZeroExtendInstruction_value.Get());
 2263                 }
 2264             }
 2265             public void PreTruncateInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2266             {
 2267                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2268                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2269                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2270             }
 2271             public void PostTruncateInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2272             {
 2273                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2274                 if (matched)
 2275                 {
 2276                     UniquePtr<Object> fromTruncateInstruction_value = stack.Pop();
 2277                     context->fromTruncateInstruction = *cast<ValueObject<Instruction*>*>(fromTruncateInstruction_value.Get());
 2278                 }
 2279             }
 2280             public void PreBitCastInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2281             {
 2282                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2283                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2284                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2285             }
 2286             public void PostBitCastInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2287             {
 2288                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2289                 if (matched)
 2290                 {
 2291                     UniquePtr<Object> fromBitCastInstruction_value = stack.Pop();
 2292                     context->fromBitCastInstruction = *cast<ValueObject<Instruction*>*>(fromBitCastInstruction_value.Get());
 2293                 }
 2294             }
 2295             public void PreIntToFloatInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2296             {
 2297                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2298                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2299                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2300             }
 2301             public void PostIntToFloatInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2302             {
 2303                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2304                 if (matched)
 2305                 {
 2306                     UniquePtr<Object> fromIntToFloatInstruction_value = stack.Pop();
 2307                     context->fromIntToFloatInstruction = *cast<ValueObject<Instruction*>*>(fromIntToFloatInstruction_value.Get());
 2308                 }
 2309             }
 2310             public void PreFloatToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2311             {
 2312                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2313                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2314                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2315             }
 2316             public void PostFloatToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2317             {
 2318                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2319                 if (matched)
 2320                 {
 2321                     UniquePtr<Object> fromFloatToIntInstruction_value = stack.Pop();
 2322                     context->fromFloatToIntInstruction = *cast<ValueObject<Instruction*>*>(fromFloatToIntInstruction_value.Get());
 2323                 }
 2324             }
 2325             public void PreIntToPtrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2326             {
 2327                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2328                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2329                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2330             }
 2331             public void PostIntToPtrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2332             {
 2333                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2334                 if (matched)
 2335                 {
 2336                     UniquePtr<Object> fromIntToPtrInstruction_value = stack.Pop();
 2337                     context->fromIntToPtrInstruction = *cast<ValueObject<Instruction*>*>(fromIntToPtrInstruction_value.Get());
 2338                 }
 2339             }
 2340             public void PrePtrToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2341             {
 2342                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2343                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2344                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 2345             }
 2346             public void PostPtrToIntInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2347             {
 2348                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2349                 if (matched)
 2350                 {
 2351                     UniquePtr<Object> fromPtrToIntInstruction_value = stack.Pop();
 2352                     context->fromPtrToIntInstruction = *cast<ValueObject<Instruction*>*>(fromPtrToIntInstruction_value.Get());
 2353                 }
 2354             }
 2355             public class Context : System.Text.Parsing.Context
 2356             {
 2357                 public Context() : context(), result(), value(), fromNotInstruction(), fromNegInstruction(), fromSignExtendInstruction(), fromZeroExtendInstruction(), fromTruncateInstruction(), fromBitCastInstruction(), fromIntToFloatInstruction(), fromFloatToIntInstruction(), fromIntToPtrInstruction(), fromPtrToIntInstruction()
 2358                 {
 2359                 }
 2360                 public cmsx.intermediate.Context* context;
 2361                 public Value* result;
 2362                 public Instruction* value;
 2363                 public Instruction* fromNotInstruction;
 2364                 public Instruction* fromNegInstruction;
 2365                 public Instruction* fromSignExtendInstruction;
 2366                 public Instruction* fromZeroExtendInstruction;
 2367                 public Instruction* fromTruncateInstruction;
 2368                 public Instruction* fromBitCastInstruction;
 2369                 public Instruction* fromIntToFloatInstruction;
 2370                 public Instruction* fromFloatToIntInstruction;
 2371                 public Instruction* fromIntToPtrInstruction;
 2372                 public Instruction* fromPtrToIntInstruction;
 2373             }
 2374         }
 2375 
 2376         public class NotInstructionRule : System.Text.Parsing.RuleParser
 2377         {
 2378             public NotInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2379             {
 2380                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2381                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2382                 SetValueTypeName(ToUtf32("Instruction*"));
 2383             }
 2384             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2385             {
 2386                 parsingData->PushContext(Id(), new Context());
 2387                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2388                 UniquePtr<Object> result_value = stack.Pop();
 2389                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2390                 UniquePtr<Object> context_value = stack.Pop();
 2391                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2392             }
 2393             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2394             {
 2395                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2396                 if (matched)
 2397                 {
 2398                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2399                 }
 2400                 parsingData->PopContext(Id());
 2401             }
 2402             public override void Link()
 2403             {
 2404                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2405                 a0ActionParser->SetAction(A0Action);
 2406                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2407                 argNonterminalParser->SetPre(Prearg);
 2408                 argNonterminalParser->SetPost(Postarg);
 2409             }
 2410             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2411             {
 2412                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2413                 context->value = new NotInstruction(context->result, context->fromarg, span.lineNumber);
 2414             }
 2415             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2416             {
 2417                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2418                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2419             }
 2420             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2421             {
 2422                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2423                 if (matched)
 2424                 {
 2425                     UniquePtr<Object> fromarg_value = stack.Pop();
 2426                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2427                 }
 2428             }
 2429             public class Context : System.Text.Parsing.Context
 2430             {
 2431                 public Context() : context(), result(), value(), fromarg()
 2432                 {
 2433                 }
 2434                 public cmsx.intermediate.Context* context;
 2435                 public Value* result;
 2436                 public Instruction* value;
 2437                 public Value* fromarg;
 2438             }
 2439         }
 2440 
 2441         public class NegInstructionRule : System.Text.Parsing.RuleParser
 2442         {
 2443             public NegInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2444             {
 2445                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2446                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2447                 SetValueTypeName(ToUtf32("Instruction*"));
 2448             }
 2449             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2450             {
 2451                 parsingData->PushContext(Id(), new Context());
 2452                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2453                 UniquePtr<Object> result_value = stack.Pop();
 2454                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2455                 UniquePtr<Object> context_value = stack.Pop();
 2456                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2457             }
 2458             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2459             {
 2460                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2461                 if (matched)
 2462                 {
 2463                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2464                 }
 2465                 parsingData->PopContext(Id());
 2466             }
 2467             public override void Link()
 2468             {
 2469                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2470                 a0ActionParser->SetAction(A0Action);
 2471                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2472                 argNonterminalParser->SetPre(Prearg);
 2473                 argNonterminalParser->SetPost(Postarg);
 2474             }
 2475             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2476             {
 2477                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2478                 context->value = new NegInstruction(context->result, context->fromarg, span.lineNumber);
 2479             }
 2480             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2481             {
 2482                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2483                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2484             }
 2485             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2486             {
 2487                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2488                 if (matched)
 2489                 {
 2490                     UniquePtr<Object> fromarg_value = stack.Pop();
 2491                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2492                 }
 2493             }
 2494             public class Context : System.Text.Parsing.Context
 2495             {
 2496                 public Context() : context(), result(), value(), fromarg()
 2497                 {
 2498                 }
 2499                 public cmsx.intermediate.Context* context;
 2500                 public Value* result;
 2501                 public Instruction* value;
 2502                 public Value* fromarg;
 2503             }
 2504         }
 2505 
 2506         public class SignExtendInstructionRule : System.Text.Parsing.RuleParser
 2507         {
 2508             public SignExtendInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2509             {
 2510                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2511                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2512                 SetValueTypeName(ToUtf32("Instruction*"));
 2513             }
 2514             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2515             {
 2516                 parsingData->PushContext(Id(), new Context());
 2517                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2518                 UniquePtr<Object> result_value = stack.Pop();
 2519                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2520                 UniquePtr<Object> context_value = stack.Pop();
 2521                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2522             }
 2523             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2524             {
 2525                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2526                 if (matched)
 2527                 {
 2528                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2529                 }
 2530                 parsingData->PopContext(Id());
 2531             }
 2532             public override void Link()
 2533             {
 2534                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2535                 a0ActionParser->SetAction(A0Action);
 2536                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2537                 argNonterminalParser->SetPre(Prearg);
 2538                 argNonterminalParser->SetPost(Postarg);
 2539             }
 2540             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2541             {
 2542                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2543                 context->value = new SignExtendInstruction(context->result, context->fromarg, span.lineNumber);
 2544             }
 2545             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2546             {
 2547                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2548                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2549             }
 2550             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2551             {
 2552                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2553                 if (matched)
 2554                 {
 2555                     UniquePtr<Object> fromarg_value = stack.Pop();
 2556                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2557                 }
 2558             }
 2559             public class Context : System.Text.Parsing.Context
 2560             {
 2561                 public Context() : context(), result(), value(), fromarg()
 2562                 {
 2563                 }
 2564                 public cmsx.intermediate.Context* context;
 2565                 public Value* result;
 2566                 public Instruction* value;
 2567                 public Value* fromarg;
 2568             }
 2569         }
 2570 
 2571         public class ZeroExtendInstructionRule : System.Text.Parsing.RuleParser
 2572         {
 2573             public ZeroExtendInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2574             {
 2575                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2576                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2577                 SetValueTypeName(ToUtf32("Instruction*"));
 2578             }
 2579             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2580             {
 2581                 parsingData->PushContext(Id(), new Context());
 2582                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2583                 UniquePtr<Object> result_value = stack.Pop();
 2584                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2585                 UniquePtr<Object> context_value = stack.Pop();
 2586                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2587             }
 2588             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2589             {
 2590                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2591                 if (matched)
 2592                 {
 2593                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2594                 }
 2595                 parsingData->PopContext(Id());
 2596             }
 2597             public override void Link()
 2598             {
 2599                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2600                 a0ActionParser->SetAction(A0Action);
 2601                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2602                 argNonterminalParser->SetPre(Prearg);
 2603                 argNonterminalParser->SetPost(Postarg);
 2604             }
 2605             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2606             {
 2607                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2608                 context->value = new ZeroExtendInstruction(context->result, context->fromarg, span.lineNumber);
 2609             }
 2610             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2611             {
 2612                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2613                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2614             }
 2615             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2616             {
 2617                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2618                 if (matched)
 2619                 {
 2620                     UniquePtr<Object> fromarg_value = stack.Pop();
 2621                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2622                 }
 2623             }
 2624             public class Context : System.Text.Parsing.Context
 2625             {
 2626                 public Context() : context(), result(), value(), fromarg()
 2627                 {
 2628                 }
 2629                 public cmsx.intermediate.Context* context;
 2630                 public Value* result;
 2631                 public Instruction* value;
 2632                 public Value* fromarg;
 2633             }
 2634         }
 2635 
 2636         public class TruncateInstructionRule : System.Text.Parsing.RuleParser
 2637         {
 2638             public TruncateInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2639             {
 2640                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2641                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2642                 SetValueTypeName(ToUtf32("Instruction*"));
 2643             }
 2644             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2645             {
 2646                 parsingData->PushContext(Id(), new Context());
 2647                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2648                 UniquePtr<Object> result_value = stack.Pop();
 2649                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2650                 UniquePtr<Object> context_value = stack.Pop();
 2651                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2652             }
 2653             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2654             {
 2655                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2656                 if (matched)
 2657                 {
 2658                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2659                 }
 2660                 parsingData->PopContext(Id());
 2661             }
 2662             public override void Link()
 2663             {
 2664                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2665                 a0ActionParser->SetAction(A0Action);
 2666                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2667                 argNonterminalParser->SetPre(Prearg);
 2668                 argNonterminalParser->SetPost(Postarg);
 2669             }
 2670             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2671             {
 2672                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2673                 context->value = new TruncateInstruction(context->result, context->fromarg, span.lineNumber);
 2674             }
 2675             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2676             {
 2677                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2678                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2679             }
 2680             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2681             {
 2682                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2683                 if (matched)
 2684                 {
 2685                     UniquePtr<Object> fromarg_value = stack.Pop();
 2686                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2687                 }
 2688             }
 2689             public class Context : System.Text.Parsing.Context
 2690             {
 2691                 public Context() : context(), result(), value(), fromarg()
 2692                 {
 2693                 }
 2694                 public cmsx.intermediate.Context* context;
 2695                 public Value* result;
 2696                 public Instruction* value;
 2697                 public Value* fromarg;
 2698             }
 2699         }
 2700 
 2701         public class BitCastInstructionRule : System.Text.Parsing.RuleParser
 2702         {
 2703             public BitCastInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2704             {
 2705                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2706                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2707                 SetValueTypeName(ToUtf32("Instruction*"));
 2708             }
 2709             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2710             {
 2711                 parsingData->PushContext(Id(), new Context());
 2712                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2713                 UniquePtr<Object> result_value = stack.Pop();
 2714                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2715                 UniquePtr<Object> context_value = stack.Pop();
 2716                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2717             }
 2718             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2719             {
 2720                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2721                 if (matched)
 2722                 {
 2723                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2724                 }
 2725                 parsingData->PopContext(Id());
 2726             }
 2727             public override void Link()
 2728             {
 2729                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2730                 a0ActionParser->SetAction(A0Action);
 2731                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2732                 argNonterminalParser->SetPre(Prearg);
 2733                 argNonterminalParser->SetPost(Postarg);
 2734             }
 2735             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2736             {
 2737                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2738                 context->value = new BitCastInstruction(context->result, context->fromarg, span.lineNumber);
 2739             }
 2740             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2741             {
 2742                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2743                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2744             }
 2745             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2746             {
 2747                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2748                 if (matched)
 2749                 {
 2750                     UniquePtr<Object> fromarg_value = stack.Pop();
 2751                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2752                 }
 2753             }
 2754             public class Context : System.Text.Parsing.Context
 2755             {
 2756                 public Context() : context(), result(), value(), fromarg()
 2757                 {
 2758                 }
 2759                 public cmsx.intermediate.Context* context;
 2760                 public Value* result;
 2761                 public Instruction* value;
 2762                 public Value* fromarg;
 2763             }
 2764         }
 2765 
 2766         public class IntToFloatInstructionRule : System.Text.Parsing.RuleParser
 2767         {
 2768             public IntToFloatInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2769             {
 2770                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2771                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2772                 SetValueTypeName(ToUtf32("Instruction*"));
 2773             }
 2774             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2775             {
 2776                 parsingData->PushContext(Id(), new Context());
 2777                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2778                 UniquePtr<Object> result_value = stack.Pop();
 2779                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2780                 UniquePtr<Object> context_value = stack.Pop();
 2781                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2782             }
 2783             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2784             {
 2785                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2786                 if (matched)
 2787                 {
 2788                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2789                 }
 2790                 parsingData->PopContext(Id());
 2791             }
 2792             public override void Link()
 2793             {
 2794                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2795                 a0ActionParser->SetAction(A0Action);
 2796                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2797                 argNonterminalParser->SetPre(Prearg);
 2798                 argNonterminalParser->SetPost(Postarg);
 2799             }
 2800             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2801             {
 2802                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2803                 context->value = new IntToFloatInstruction(context->result, context->fromarg, span.lineNumber);
 2804             }
 2805             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2806             {
 2807                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2808                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2809             }
 2810             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2811             {
 2812                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2813                 if (matched)
 2814                 {
 2815                     UniquePtr<Object> fromarg_value = stack.Pop();
 2816                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2817                 }
 2818             }
 2819             public class Context : System.Text.Parsing.Context
 2820             {
 2821                 public Context() : context(), result(), value(), fromarg()
 2822                 {
 2823                 }
 2824                 public cmsx.intermediate.Context* context;
 2825                 public Value* result;
 2826                 public Instruction* value;
 2827                 public Value* fromarg;
 2828             }
 2829         }
 2830 
 2831         public class FloatToIntInstructionRule : System.Text.Parsing.RuleParser
 2832         {
 2833             public FloatToIntInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2834             {
 2835                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2836                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2837                 SetValueTypeName(ToUtf32("Instruction*"));
 2838             }
 2839             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2840             {
 2841                 parsingData->PushContext(Id(), new Context());
 2842                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2843                 UniquePtr<Object> result_value = stack.Pop();
 2844                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2845                 UniquePtr<Object> context_value = stack.Pop();
 2846                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2847             }
 2848             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2849             {
 2850                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2851                 if (matched)
 2852                 {
 2853                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2854                 }
 2855                 parsingData->PopContext(Id());
 2856             }
 2857             public override void Link()
 2858             {
 2859                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2860                 a0ActionParser->SetAction(A0Action);
 2861                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2862                 argNonterminalParser->SetPre(Prearg);
 2863                 argNonterminalParser->SetPost(Postarg);
 2864             }
 2865             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2866             {
 2867                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2868                 context->value = new FloatToIntInstruction(context->result, context->fromarg, span.lineNumber);
 2869             }
 2870             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2871             {
 2872                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2873                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2874             }
 2875             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2876             {
 2877                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2878                 if (matched)
 2879                 {
 2880                     UniquePtr<Object> fromarg_value = stack.Pop();
 2881                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2882                 }
 2883             }
 2884             public class Context : System.Text.Parsing.Context
 2885             {
 2886                 public Context() : context(), result(), value(), fromarg()
 2887                 {
 2888                 }
 2889                 public cmsx.intermediate.Context* context;
 2890                 public Value* result;
 2891                 public Instruction* value;
 2892                 public Value* fromarg;
 2893             }
 2894         }
 2895 
 2896         public class IntToPtrInstructionRule : System.Text.Parsing.RuleParser
 2897         {
 2898             public IntToPtrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2899             {
 2900                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2901                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2902                 SetValueTypeName(ToUtf32("Instruction*"));
 2903             }
 2904             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2905             {
 2906                 parsingData->PushContext(Id(), new Context());
 2907                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2908                 UniquePtr<Object> result_value = stack.Pop();
 2909                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2910                 UniquePtr<Object> context_value = stack.Pop();
 2911                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2912             }
 2913             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2914             {
 2915                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2916                 if (matched)
 2917                 {
 2918                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2919                 }
 2920                 parsingData->PopContext(Id());
 2921             }
 2922             public override void Link()
 2923             {
 2924                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2925                 a0ActionParser->SetAction(A0Action);
 2926                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2927                 argNonterminalParser->SetPre(Prearg);
 2928                 argNonterminalParser->SetPost(Postarg);
 2929             }
 2930             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2931             {
 2932                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2933                 context->value = new IntToPtrInstruction(context->result, context->fromarg, span.lineNumber);
 2934             }
 2935             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2936             {
 2937                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2938                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 2939             }
 2940             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2941             {
 2942                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2943                 if (matched)
 2944                 {
 2945                     UniquePtr<Object> fromarg_value = stack.Pop();
 2946                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 2947                 }
 2948             }
 2949             public class Context : System.Text.Parsing.Context
 2950             {
 2951                 public Context() : context(), result(), value(), fromarg()
 2952                 {
 2953                 }
 2954                 public cmsx.intermediate.Context* context;
 2955                 public Value* result;
 2956                 public Instruction* value;
 2957                 public Value* fromarg;
 2958             }
 2959         }
 2960 
 2961         public class PtrToIntInstructionRule : System.Text.Parsing.RuleParser
 2962         {
 2963             public PtrToIntInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 2964             {
 2965                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 2966                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 2967                 SetValueTypeName(ToUtf32("Instruction*"));
 2968             }
 2969             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 2970             {
 2971                 parsingData->PushContext(Id(), new Context());
 2972                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2973                 UniquePtr<Object> result_value = stack.Pop();
 2974                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 2975                 UniquePtr<Object> context_value = stack.Pop();
 2976                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 2977             }
 2978             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 2979             {
 2980                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2981                 if (matched)
 2982                 {
 2983                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 2984                 }
 2985                 parsingData->PopContext(Id());
 2986             }
 2987             public override void Link()
 2988             {
 2989                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 2990                 a0ActionParser->SetAction(A0Action);
 2991                 NonterminalParser* argNonterminalParser = GetNonterminal(ToUtf32("arg"));
 2992                 argNonterminalParser->SetPre(Prearg);
 2993                 argNonterminalParser->SetPost(Postarg);
 2994             }
 2995             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 2996             {
 2997                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 2998                 context->value = new PtrToIntInstruction(context->result, context->fromarg, span.lineNumber);
 2999             }
 3000             public void Prearg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3001             {
 3002                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3003                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3004             }
 3005             public void Postarg(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3006             {
 3007                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3008                 if (matched)
 3009                 {
 3010                     UniquePtr<Object> fromarg_value = stack.Pop();
 3011                     context->fromarg = *cast<ValueObject<Value*>*>(fromarg_value.Get());
 3012                 }
 3013             }
 3014             public class Context : System.Text.Parsing.Context
 3015             {
 3016                 public Context() : context(), result(), value(), fromarg()
 3017                 {
 3018                 }
 3019                 public cmsx.intermediate.Context* context;
 3020                 public Value* result;
 3021                 public Instruction* value;
 3022                 public Value* fromarg;
 3023             }
 3024         }
 3025 
 3026         public class BinaryInstructionRule : System.Text.Parsing.RuleParser
 3027         {
 3028             public BinaryInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3029             {
 3030                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3031                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3032                 SetValueTypeName(ToUtf32("Instruction*"));
 3033             }
 3034             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3035             {
 3036                 parsingData->PushContext(Id(), new Context());
 3037                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3038                 UniquePtr<Object> result_value = stack.Pop();
 3039                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3040                 UniquePtr<Object> context_value = stack.Pop();
 3041                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3042             }
 3043             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3044             {
 3045                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3046                 if (matched)
 3047                 {
 3048                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3049                 }
 3050                 parsingData->PopContext(Id());
 3051             }
 3052             public override void Link()
 3053             {
 3054                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3055                 a0ActionParser->SetAction(A0Action);
 3056                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 3057                 a1ActionParser->SetAction(A1Action);
 3058                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 3059                 a2ActionParser->SetAction(A2Action);
 3060                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 3061                 a3ActionParser->SetAction(A3Action);
 3062                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 3063                 a4ActionParser->SetAction(A4Action);
 3064                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 3065                 a5ActionParser->SetAction(A5Action);
 3066                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 3067                 a6ActionParser->SetAction(A6Action);
 3068                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 3069                 a7ActionParser->SetAction(A7Action);
 3070                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 3071                 a8ActionParser->SetAction(A8Action);
 3072                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 3073                 a9ActionParser->SetAction(A9Action);
 3074                 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
 3075                 a10ActionParser->SetAction(A10Action);
 3076                 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
 3077                 a11ActionParser->SetAction(A11Action);
 3078                 NonterminalParser* addInstructionNonterminalParser = GetNonterminal(ToUtf32("AddInstruction"));
 3079                 addInstructionNonterminalParser->SetPre(PreAddInstruction);
 3080                 addInstructionNonterminalParser->SetPost(PostAddInstruction);
 3081                 NonterminalParser* subInstructionNonterminalParser = GetNonterminal(ToUtf32("SubInstruction"));
 3082                 subInstructionNonterminalParser->SetPre(PreSubInstruction);
 3083                 subInstructionNonterminalParser->SetPost(PostSubInstruction);
 3084                 NonterminalParser* mulInstructionNonterminalParser = GetNonterminal(ToUtf32("MulInstruction"));
 3085                 mulInstructionNonterminalParser->SetPre(PreMulInstruction);
 3086                 mulInstructionNonterminalParser->SetPost(PostMulInstruction);
 3087                 NonterminalParser* divInstructionNonterminalParser = GetNonterminal(ToUtf32("DivInstruction"));
 3088                 divInstructionNonterminalParser->SetPre(PreDivInstruction);
 3089                 divInstructionNonterminalParser->SetPost(PostDivInstruction);
 3090                 NonterminalParser* modInstructionNonterminalParser = GetNonterminal(ToUtf32("ModInstruction"));
 3091                 modInstructionNonterminalParser->SetPre(PreModInstruction);
 3092                 modInstructionNonterminalParser->SetPost(PostModInstruction);
 3093                 NonterminalParser* andInstructionNonterminalParser = GetNonterminal(ToUtf32("AndInstruction"));
 3094                 andInstructionNonterminalParser->SetPre(PreAndInstruction);
 3095                 andInstructionNonterminalParser->SetPost(PostAndInstruction);
 3096                 NonterminalParser* orInstructionNonterminalParser = GetNonterminal(ToUtf32("OrInstruction"));
 3097                 orInstructionNonterminalParser->SetPre(PreOrInstruction);
 3098                 orInstructionNonterminalParser->SetPost(PostOrInstruction);
 3099                 NonterminalParser* xorInstructionNonterminalParser = GetNonterminal(ToUtf32("XorInstruction"));
 3100                 xorInstructionNonterminalParser->SetPre(PreXorInstruction);
 3101                 xorInstructionNonterminalParser->SetPost(PostXorInstruction);
 3102                 NonterminalParser* shlInstructionNonterminalParser = GetNonterminal(ToUtf32("ShlInstruction"));
 3103                 shlInstructionNonterminalParser->SetPre(PreShlInstruction);
 3104                 shlInstructionNonterminalParser->SetPost(PostShlInstruction);
 3105                 NonterminalParser* shrInstructionNonterminalParser = GetNonterminal(ToUtf32("ShrInstruction"));
 3106                 shrInstructionNonterminalParser->SetPre(PreShrInstruction);
 3107                 shrInstructionNonterminalParser->SetPost(PostShrInstruction);
 3108                 NonterminalParser* equalInstructionNonterminalParser = GetNonterminal(ToUtf32("EqualInstruction"));
 3109                 equalInstructionNonterminalParser->SetPre(PreEqualInstruction);
 3110                 equalInstructionNonterminalParser->SetPost(PostEqualInstruction);
 3111                 NonterminalParser* lessInstructionNonterminalParser = GetNonterminal(ToUtf32("LessInstruction"));
 3112                 lessInstructionNonterminalParser->SetPre(PreLessInstruction);
 3113                 lessInstructionNonterminalParser->SetPost(PostLessInstruction);
 3114             }
 3115             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3116             {
 3117                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3118                 context->value = context->fromAddInstruction;
 3119             }
 3120             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3121             {
 3122                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3123                 context->value = context->fromSubInstruction;
 3124             }
 3125             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3126             {
 3127                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3128                 context->value = context->fromMulInstruction;
 3129             }
 3130             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3131             {
 3132                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3133                 context->value = context->fromDivInstruction;
 3134             }
 3135             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3136             {
 3137                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3138                 context->value = context->fromModInstruction;
 3139             }
 3140             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3141             {
 3142                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3143                 context->value = context->fromAndInstruction;
 3144             }
 3145             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3146             {
 3147                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3148                 context->value = context->fromOrInstruction;
 3149             }
 3150             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3151             {
 3152                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3153                 context->value = context->fromXorInstruction;
 3154             }
 3155             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3156             {
 3157                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3158                 context->value = context->fromShlInstruction;
 3159             }
 3160             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3161             {
 3162                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3163                 context->value = context->fromShrInstruction;
 3164             }
 3165             public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3166             {
 3167                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3168                 context->value = context->fromEqualInstruction;
 3169             }
 3170             public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3171             {
 3172                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3173                 context->value = context->fromLessInstruction;
 3174             }
 3175             public void PreAddInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3176             {
 3177                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3178                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3179                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3180             }
 3181             public void PostAddInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3182             {
 3183                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3184                 if (matched)
 3185                 {
 3186                     UniquePtr<Object> fromAddInstruction_value = stack.Pop();
 3187                     context->fromAddInstruction = *cast<ValueObject<Instruction*>*>(fromAddInstruction_value.Get());
 3188                 }
 3189             }
 3190             public void PreSubInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3191             {
 3192                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3193                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3194                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3195             }
 3196             public void PostSubInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3197             {
 3198                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3199                 if (matched)
 3200                 {
 3201                     UniquePtr<Object> fromSubInstruction_value = stack.Pop();
 3202                     context->fromSubInstruction = *cast<ValueObject<Instruction*>*>(fromSubInstruction_value.Get());
 3203                 }
 3204             }
 3205             public void PreMulInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3206             {
 3207                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3208                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3209                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3210             }
 3211             public void PostMulInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3212             {
 3213                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3214                 if (matched)
 3215                 {
 3216                     UniquePtr<Object> fromMulInstruction_value = stack.Pop();
 3217                     context->fromMulInstruction = *cast<ValueObject<Instruction*>*>(fromMulInstruction_value.Get());
 3218                 }
 3219             }
 3220             public void PreDivInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3221             {
 3222                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3223                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3224                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3225             }
 3226             public void PostDivInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3227             {
 3228                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3229                 if (matched)
 3230                 {
 3231                     UniquePtr<Object> fromDivInstruction_value = stack.Pop();
 3232                     context->fromDivInstruction = *cast<ValueObject<Instruction*>*>(fromDivInstruction_value.Get());
 3233                 }
 3234             }
 3235             public void PreModInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3236             {
 3237                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3238                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3239                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3240             }
 3241             public void PostModInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3242             {
 3243                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3244                 if (matched)
 3245                 {
 3246                     UniquePtr<Object> fromModInstruction_value = stack.Pop();
 3247                     context->fromModInstruction = *cast<ValueObject<Instruction*>*>(fromModInstruction_value.Get());
 3248                 }
 3249             }
 3250             public void PreAndInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3251             {
 3252                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3253                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3254                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3255             }
 3256             public void PostAndInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3257             {
 3258                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3259                 if (matched)
 3260                 {
 3261                     UniquePtr<Object> fromAndInstruction_value = stack.Pop();
 3262                     context->fromAndInstruction = *cast<ValueObject<Instruction*>*>(fromAndInstruction_value.Get());
 3263                 }
 3264             }
 3265             public void PreOrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3266             {
 3267                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3268                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3269                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3270             }
 3271             public void PostOrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3272             {
 3273                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3274                 if (matched)
 3275                 {
 3276                     UniquePtr<Object> fromOrInstruction_value = stack.Pop();
 3277                     context->fromOrInstruction = *cast<ValueObject<Instruction*>*>(fromOrInstruction_value.Get());
 3278                 }
 3279             }
 3280             public void PreXorInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3281             {
 3282                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3283                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3284                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3285             }
 3286             public void PostXorInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3287             {
 3288                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3289                 if (matched)
 3290                 {
 3291                     UniquePtr<Object> fromXorInstruction_value = stack.Pop();
 3292                     context->fromXorInstruction = *cast<ValueObject<Instruction*>*>(fromXorInstruction_value.Get());
 3293                 }
 3294             }
 3295             public void PreShlInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3296             {
 3297                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3298                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3299                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3300             }
 3301             public void PostShlInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3302             {
 3303                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3304                 if (matched)
 3305                 {
 3306                     UniquePtr<Object> fromShlInstruction_value = stack.Pop();
 3307                     context->fromShlInstruction = *cast<ValueObject<Instruction*>*>(fromShlInstruction_value.Get());
 3308                 }
 3309             }
 3310             public void PreShrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3311             {
 3312                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3313                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3314                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3315             }
 3316             public void PostShrInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3317             {
 3318                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3319                 if (matched)
 3320                 {
 3321                     UniquePtr<Object> fromShrInstruction_value = stack.Pop();
 3322                     context->fromShrInstruction = *cast<ValueObject<Instruction*>*>(fromShrInstruction_value.Get());
 3323                 }
 3324             }
 3325             public void PreEqualInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3326             {
 3327                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3328                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3329                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3330             }
 3331             public void PostEqualInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3332             {
 3333                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3334                 if (matched)
 3335                 {
 3336                     UniquePtr<Object> fromEqualInstruction_value = stack.Pop();
 3337                     context->fromEqualInstruction = *cast<ValueObject<Instruction*>*>(fromEqualInstruction_value.Get());
 3338                 }
 3339             }
 3340             public void PreLessInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3341             {
 3342                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3343                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3344                 stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->result)));
 3345             }
 3346             public void PostLessInstruction(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3347             {
 3348                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3349                 if (matched)
 3350                 {
 3351                     UniquePtr<Object> fromLessInstruction_value = stack.Pop();
 3352                     context->fromLessInstruction = *cast<ValueObject<Instruction*>*>(fromLessInstruction_value.Get());
 3353                 }
 3354             }
 3355             public class Context : System.Text.Parsing.Context
 3356             {
 3357                 public Context() : context(), result(), value(), fromAddInstruction(), fromSubInstruction(), fromMulInstruction(), fromDivInstruction(), fromModInstruction(), fromAndInstruction(), fromOrInstruction(), fromXorInstruction(), fromShlInstruction(), fromShrInstruction(), fromEqualInstruction(), fromLessInstruction()
 3358                 {
 3359                 }
 3360                 public cmsx.intermediate.Context* context;
 3361                 public Value* result;
 3362                 public Instruction* value;
 3363                 public Instruction* fromAddInstruction;
 3364                 public Instruction* fromSubInstruction;
 3365                 public Instruction* fromMulInstruction;
 3366                 public Instruction* fromDivInstruction;
 3367                 public Instruction* fromModInstruction;
 3368                 public Instruction* fromAndInstruction;
 3369                 public Instruction* fromOrInstruction;
 3370                 public Instruction* fromXorInstruction;
 3371                 public Instruction* fromShlInstruction;
 3372                 public Instruction* fromShrInstruction;
 3373                 public Instruction* fromEqualInstruction;
 3374                 public Instruction* fromLessInstruction;
 3375             }
 3376         }
 3377 
 3378         public class AddInstructionRule : System.Text.Parsing.RuleParser
 3379         {
 3380             public AddInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3381             {
 3382                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3383                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3384                 SetValueTypeName(ToUtf32("Instruction*"));
 3385             }
 3386             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3387             {
 3388                 parsingData->PushContext(Id(), new Context());
 3389                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3390                 UniquePtr<Object> result_value = stack.Pop();
 3391                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3392                 UniquePtr<Object> context_value = stack.Pop();
 3393                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3394             }
 3395             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3396             {
 3397                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3398                 if (matched)
 3399                 {
 3400                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3401                 }
 3402                 parsingData->PopContext(Id());
 3403             }
 3404             public override void Link()
 3405             {
 3406                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3407                 a0ActionParser->SetAction(A0Action);
 3408                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3409                 leftNonterminalParser->SetPre(Preleft);
 3410                 leftNonterminalParser->SetPost(Postleft);
 3411                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3412                 rightNonterminalParser->SetPre(Preright);
 3413                 rightNonterminalParser->SetPost(Postright);
 3414             }
 3415             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3416             {
 3417                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3418                 context->value = new AddInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3419             }
 3420             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3421             {
 3422                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3423                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3424             }
 3425             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3426             {
 3427                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3428                 if (matched)
 3429                 {
 3430                     UniquePtr<Object> fromleft_value = stack.Pop();
 3431                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3432                 }
 3433             }
 3434             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3435             {
 3436                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3437                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3438             }
 3439             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3440             {
 3441                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3442                 if (matched)
 3443                 {
 3444                     UniquePtr<Object> fromright_value = stack.Pop();
 3445                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3446                 }
 3447             }
 3448             public class Context : System.Text.Parsing.Context
 3449             {
 3450                 public Context() : context(), result(), value(), fromleft(), fromright()
 3451                 {
 3452                 }
 3453                 public cmsx.intermediate.Context* context;
 3454                 public Value* result;
 3455                 public Instruction* value;
 3456                 public Value* fromleft;
 3457                 public Value* fromright;
 3458             }
 3459         }
 3460 
 3461         public class SubInstructionRule : System.Text.Parsing.RuleParser
 3462         {
 3463             public SubInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3464             {
 3465                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3466                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3467                 SetValueTypeName(ToUtf32("Instruction*"));
 3468             }
 3469             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3470             {
 3471                 parsingData->PushContext(Id(), new Context());
 3472                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3473                 UniquePtr<Object> result_value = stack.Pop();
 3474                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3475                 UniquePtr<Object> context_value = stack.Pop();
 3476                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3477             }
 3478             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3479             {
 3480                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3481                 if (matched)
 3482                 {
 3483                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3484                 }
 3485                 parsingData->PopContext(Id());
 3486             }
 3487             public override void Link()
 3488             {
 3489                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3490                 a0ActionParser->SetAction(A0Action);
 3491                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3492                 leftNonterminalParser->SetPre(Preleft);
 3493                 leftNonterminalParser->SetPost(Postleft);
 3494                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3495                 rightNonterminalParser->SetPre(Preright);
 3496                 rightNonterminalParser->SetPost(Postright);
 3497             }
 3498             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3499             {
 3500                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3501                 context->value = new SubInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3502             }
 3503             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3504             {
 3505                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3506                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3507             }
 3508             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3509             {
 3510                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3511                 if (matched)
 3512                 {
 3513                     UniquePtr<Object> fromleft_value = stack.Pop();
 3514                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3515                 }
 3516             }
 3517             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3518             {
 3519                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3520                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3521             }
 3522             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3523             {
 3524                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3525                 if (matched)
 3526                 {
 3527                     UniquePtr<Object> fromright_value = stack.Pop();
 3528                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3529                 }
 3530             }
 3531             public class Context : System.Text.Parsing.Context
 3532             {
 3533                 public Context() : context(), result(), value(), fromleft(), fromright()
 3534                 {
 3535                 }
 3536                 public cmsx.intermediate.Context* context;
 3537                 public Value* result;
 3538                 public Instruction* value;
 3539                 public Value* fromleft;
 3540                 public Value* fromright;
 3541             }
 3542         }
 3543 
 3544         public class MulInstructionRule : System.Text.Parsing.RuleParser
 3545         {
 3546             public MulInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3547             {
 3548                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3549                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3550                 SetValueTypeName(ToUtf32("Instruction*"));
 3551             }
 3552             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3553             {
 3554                 parsingData->PushContext(Id(), new Context());
 3555                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3556                 UniquePtr<Object> result_value = stack.Pop();
 3557                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3558                 UniquePtr<Object> context_value = stack.Pop();
 3559                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3560             }
 3561             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3562             {
 3563                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3564                 if (matched)
 3565                 {
 3566                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3567                 }
 3568                 parsingData->PopContext(Id());
 3569             }
 3570             public override void Link()
 3571             {
 3572                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3573                 a0ActionParser->SetAction(A0Action);
 3574                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3575                 leftNonterminalParser->SetPre(Preleft);
 3576                 leftNonterminalParser->SetPost(Postleft);
 3577                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3578                 rightNonterminalParser->SetPre(Preright);
 3579                 rightNonterminalParser->SetPost(Postright);
 3580             }
 3581             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3582             {
 3583                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3584                 context->value = new MulInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3585             }
 3586             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3587             {
 3588                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3589                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3590             }
 3591             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3592             {
 3593                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3594                 if (matched)
 3595                 {
 3596                     UniquePtr<Object> fromleft_value = stack.Pop();
 3597                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3598                 }
 3599             }
 3600             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3601             {
 3602                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3603                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3604             }
 3605             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3606             {
 3607                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3608                 if (matched)
 3609                 {
 3610                     UniquePtr<Object> fromright_value = stack.Pop();
 3611                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3612                 }
 3613             }
 3614             public class Context : System.Text.Parsing.Context
 3615             {
 3616                 public Context() : context(), result(), value(), fromleft(), fromright()
 3617                 {
 3618                 }
 3619                 public cmsx.intermediate.Context* context;
 3620                 public Value* result;
 3621                 public Instruction* value;
 3622                 public Value* fromleft;
 3623                 public Value* fromright;
 3624             }
 3625         }
 3626 
 3627         public class DivInstructionRule : System.Text.Parsing.RuleParser
 3628         {
 3629             public DivInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3630             {
 3631                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3632                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3633                 SetValueTypeName(ToUtf32("Instruction*"));
 3634             }
 3635             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3636             {
 3637                 parsingData->PushContext(Id(), new Context());
 3638                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3639                 UniquePtr<Object> result_value = stack.Pop();
 3640                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3641                 UniquePtr<Object> context_value = stack.Pop();
 3642                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3643             }
 3644             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3645             {
 3646                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3647                 if (matched)
 3648                 {
 3649                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3650                 }
 3651                 parsingData->PopContext(Id());
 3652             }
 3653             public override void Link()
 3654             {
 3655                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3656                 a0ActionParser->SetAction(A0Action);
 3657                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3658                 leftNonterminalParser->SetPre(Preleft);
 3659                 leftNonterminalParser->SetPost(Postleft);
 3660                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3661                 rightNonterminalParser->SetPre(Preright);
 3662                 rightNonterminalParser->SetPost(Postright);
 3663             }
 3664             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3665             {
 3666                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3667                 context->value = new DivInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3668             }
 3669             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3670             {
 3671                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3672                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3673             }
 3674             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3675             {
 3676                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3677                 if (matched)
 3678                 {
 3679                     UniquePtr<Object> fromleft_value = stack.Pop();
 3680                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3681                 }
 3682             }
 3683             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3684             {
 3685                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3686                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3687             }
 3688             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3689             {
 3690                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3691                 if (matched)
 3692                 {
 3693                     UniquePtr<Object> fromright_value = stack.Pop();
 3694                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3695                 }
 3696             }
 3697             public class Context : System.Text.Parsing.Context
 3698             {
 3699                 public Context() : context(), result(), value(), fromleft(), fromright()
 3700                 {
 3701                 }
 3702                 public cmsx.intermediate.Context* context;
 3703                 public Value* result;
 3704                 public Instruction* value;
 3705                 public Value* fromleft;
 3706                 public Value* fromright;
 3707             }
 3708         }
 3709 
 3710         public class ModInstructionRule : System.Text.Parsing.RuleParser
 3711         {
 3712             public ModInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3713             {
 3714                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3715                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3716                 SetValueTypeName(ToUtf32("Instruction*"));
 3717             }
 3718             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3719             {
 3720                 parsingData->PushContext(Id(), new Context());
 3721                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3722                 UniquePtr<Object> result_value = stack.Pop();
 3723                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3724                 UniquePtr<Object> context_value = stack.Pop();
 3725                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3726             }
 3727             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3728             {
 3729                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3730                 if (matched)
 3731                 {
 3732                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3733                 }
 3734                 parsingData->PopContext(Id());
 3735             }
 3736             public override void Link()
 3737             {
 3738                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3739                 a0ActionParser->SetAction(A0Action);
 3740                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3741                 leftNonterminalParser->SetPre(Preleft);
 3742                 leftNonterminalParser->SetPost(Postleft);
 3743                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3744                 rightNonterminalParser->SetPre(Preright);
 3745                 rightNonterminalParser->SetPost(Postright);
 3746             }
 3747             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3748             {
 3749                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3750                 context->value = new ModInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3751             }
 3752             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3753             {
 3754                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3755                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3756             }
 3757             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3758             {
 3759                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3760                 if (matched)
 3761                 {
 3762                     UniquePtr<Object> fromleft_value = stack.Pop();
 3763                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3764                 }
 3765             }
 3766             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3767             {
 3768                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3769                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3770             }
 3771             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3772             {
 3773                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3774                 if (matched)
 3775                 {
 3776                     UniquePtr<Object> fromright_value = stack.Pop();
 3777                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3778                 }
 3779             }
 3780             public class Context : System.Text.Parsing.Context
 3781             {
 3782                 public Context() : context(), result(), value(), fromleft(), fromright()
 3783                 {
 3784                 }
 3785                 public cmsx.intermediate.Context* context;
 3786                 public Value* result;
 3787                 public Instruction* value;
 3788                 public Value* fromleft;
 3789                 public Value* fromright;
 3790             }
 3791         }
 3792 
 3793         public class AndInstructionRule : System.Text.Parsing.RuleParser
 3794         {
 3795             public AndInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3796             {
 3797                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3798                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3799                 SetValueTypeName(ToUtf32("Instruction*"));
 3800             }
 3801             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3802             {
 3803                 parsingData->PushContext(Id(), new Context());
 3804                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3805                 UniquePtr<Object> result_value = stack.Pop();
 3806                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3807                 UniquePtr<Object> context_value = stack.Pop();
 3808                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3809             }
 3810             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3811             {
 3812                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3813                 if (matched)
 3814                 {
 3815                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3816                 }
 3817                 parsingData->PopContext(Id());
 3818             }
 3819             public override void Link()
 3820             {
 3821                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3822                 a0ActionParser->SetAction(A0Action);
 3823                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3824                 leftNonterminalParser->SetPre(Preleft);
 3825                 leftNonterminalParser->SetPost(Postleft);
 3826                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3827                 rightNonterminalParser->SetPre(Preright);
 3828                 rightNonterminalParser->SetPost(Postright);
 3829             }
 3830             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3831             {
 3832                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3833                 context->value = new AndInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3834             }
 3835             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3836             {
 3837                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3838                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3839             }
 3840             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3841             {
 3842                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3843                 if (matched)
 3844                 {
 3845                     UniquePtr<Object> fromleft_value = stack.Pop();
 3846                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3847                 }
 3848             }
 3849             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3850             {
 3851                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3852                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3853             }
 3854             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3855             {
 3856                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3857                 if (matched)
 3858                 {
 3859                     UniquePtr<Object> fromright_value = stack.Pop();
 3860                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3861                 }
 3862             }
 3863             public class Context : System.Text.Parsing.Context
 3864             {
 3865                 public Context() : context(), result(), value(), fromleft(), fromright()
 3866                 {
 3867                 }
 3868                 public cmsx.intermediate.Context* context;
 3869                 public Value* result;
 3870                 public Instruction* value;
 3871                 public Value* fromleft;
 3872                 public Value* fromright;
 3873             }
 3874         }
 3875 
 3876         public class OrInstructionRule : System.Text.Parsing.RuleParser
 3877         {
 3878             public OrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3879             {
 3880                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3881                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3882                 SetValueTypeName(ToUtf32("Instruction*"));
 3883             }
 3884             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3885             {
 3886                 parsingData->PushContext(Id(), new Context());
 3887                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3888                 UniquePtr<Object> result_value = stack.Pop();
 3889                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3890                 UniquePtr<Object> context_value = stack.Pop();
 3891                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3892             }
 3893             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3894             {
 3895                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3896                 if (matched)
 3897                 {
 3898                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3899                 }
 3900                 parsingData->PopContext(Id());
 3901             }
 3902             public override void Link()
 3903             {
 3904                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3905                 a0ActionParser->SetAction(A0Action);
 3906                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3907                 leftNonterminalParser->SetPre(Preleft);
 3908                 leftNonterminalParser->SetPost(Postleft);
 3909                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3910                 rightNonterminalParser->SetPre(Preright);
 3911                 rightNonterminalParser->SetPost(Postright);
 3912             }
 3913             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3914             {
 3915                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3916                 context->value = new OrInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 3917             }
 3918             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3919             {
 3920                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3921                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3922             }
 3923             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3924             {
 3925                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3926                 if (matched)
 3927                 {
 3928                     UniquePtr<Object> fromleft_value = stack.Pop();
 3929                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 3930                 }
 3931             }
 3932             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3933             {
 3934                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3935                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 3936             }
 3937             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3938             {
 3939                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3940                 if (matched)
 3941                 {
 3942                     UniquePtr<Object> fromright_value = stack.Pop();
 3943                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 3944                 }
 3945             }
 3946             public class Context : System.Text.Parsing.Context
 3947             {
 3948                 public Context() : context(), result(), value(), fromleft(), fromright()
 3949                 {
 3950                 }
 3951                 public cmsx.intermediate.Context* context;
 3952                 public Value* result;
 3953                 public Instruction* value;
 3954                 public Value* fromleft;
 3955                 public Value* fromright;
 3956             }
 3957         }
 3958 
 3959         public class XorInstructionRule : System.Text.Parsing.RuleParser
 3960         {
 3961             public XorInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 3962             {
 3963                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 3964                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 3965                 SetValueTypeName(ToUtf32("Instruction*"));
 3966             }
 3967             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 3968             {
 3969                 parsingData->PushContext(Id(), new Context());
 3970                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3971                 UniquePtr<Object> result_value = stack.Pop();
 3972                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 3973                 UniquePtr<Object> context_value = stack.Pop();
 3974                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 3975             }
 3976             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 3977             {
 3978                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3979                 if (matched)
 3980                 {
 3981                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 3982                 }
 3983                 parsingData->PopContext(Id());
 3984             }
 3985             public override void Link()
 3986             {
 3987                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 3988                 a0ActionParser->SetAction(A0Action);
 3989                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 3990                 leftNonterminalParser->SetPre(Preleft);
 3991                 leftNonterminalParser->SetPost(Postleft);
 3992                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 3993                 rightNonterminalParser->SetPre(Preright);
 3994                 rightNonterminalParser->SetPost(Postright);
 3995             }
 3996             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 3997             {
 3998                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 3999                 context->value = new XorInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 4000             }
 4001             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4002             {
 4003                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4004                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4005             }
 4006             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4007             {
 4008                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4009                 if (matched)
 4010                 {
 4011                     UniquePtr<Object> fromleft_value = stack.Pop();
 4012                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 4013                 }
 4014             }
 4015             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4016             {
 4017                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4018                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4019             }
 4020             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4021             {
 4022                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4023                 if (matched)
 4024                 {
 4025                     UniquePtr<Object> fromright_value = stack.Pop();
 4026                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 4027                 }
 4028             }
 4029             public class Context : System.Text.Parsing.Context
 4030             {
 4031                 public Context() : context(), result(), value(), fromleft(), fromright()
 4032                 {
 4033                 }
 4034                 public cmsx.intermediate.Context* context;
 4035                 public Value* result;
 4036                 public Instruction* value;
 4037                 public Value* fromleft;
 4038                 public Value* fromright;
 4039             }
 4040         }
 4041 
 4042         public class ShlInstructionRule : System.Text.Parsing.RuleParser
 4043         {
 4044             public ShlInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4045             {
 4046                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4047                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4048                 SetValueTypeName(ToUtf32("Instruction*"));
 4049             }
 4050             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4051             {
 4052                 parsingData->PushContext(Id(), new Context());
 4053                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4054                 UniquePtr<Object> result_value = stack.Pop();
 4055                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4056                 UniquePtr<Object> context_value = stack.Pop();
 4057                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4058             }
 4059             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4060             {
 4061                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4062                 if (matched)
 4063                 {
 4064                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4065                 }
 4066                 parsingData->PopContext(Id());
 4067             }
 4068             public override void Link()
 4069             {
 4070                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4071                 a0ActionParser->SetAction(A0Action);
 4072                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 4073                 leftNonterminalParser->SetPre(Preleft);
 4074                 leftNonterminalParser->SetPost(Postleft);
 4075                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 4076                 rightNonterminalParser->SetPre(Preright);
 4077                 rightNonterminalParser->SetPost(Postright);
 4078             }
 4079             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4080             {
 4081                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4082                 context->value = new ShlInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 4083             }
 4084             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4085             {
 4086                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4087                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4088             }
 4089             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4090             {
 4091                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4092                 if (matched)
 4093                 {
 4094                     UniquePtr<Object> fromleft_value = stack.Pop();
 4095                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 4096                 }
 4097             }
 4098             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4099             {
 4100                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4101                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4102             }
 4103             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4104             {
 4105                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4106                 if (matched)
 4107                 {
 4108                     UniquePtr<Object> fromright_value = stack.Pop();
 4109                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 4110                 }
 4111             }
 4112             public class Context : System.Text.Parsing.Context
 4113             {
 4114                 public Context() : context(), result(), value(), fromleft(), fromright()
 4115                 {
 4116                 }
 4117                 public cmsx.intermediate.Context* context;
 4118                 public Value* result;
 4119                 public Instruction* value;
 4120                 public Value* fromleft;
 4121                 public Value* fromright;
 4122             }
 4123         }
 4124 
 4125         public class ShrInstructionRule : System.Text.Parsing.RuleParser
 4126         {
 4127             public ShrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4128             {
 4129                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4130                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4131                 SetValueTypeName(ToUtf32("Instruction*"));
 4132             }
 4133             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4134             {
 4135                 parsingData->PushContext(Id(), new Context());
 4136                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4137                 UniquePtr<Object> result_value = stack.Pop();
 4138                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4139                 UniquePtr<Object> context_value = stack.Pop();
 4140                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4141             }
 4142             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4143             {
 4144                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4145                 if (matched)
 4146                 {
 4147                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4148                 }
 4149                 parsingData->PopContext(Id());
 4150             }
 4151             public override void Link()
 4152             {
 4153                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4154                 a0ActionParser->SetAction(A0Action);
 4155                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 4156                 leftNonterminalParser->SetPre(Preleft);
 4157                 leftNonterminalParser->SetPost(Postleft);
 4158                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 4159                 rightNonterminalParser->SetPre(Preright);
 4160                 rightNonterminalParser->SetPost(Postright);
 4161             }
 4162             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4163             {
 4164                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4165                 context->value = new ShrInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 4166             }
 4167             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4168             {
 4169                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4170                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4171             }
 4172             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4173             {
 4174                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4175                 if (matched)
 4176                 {
 4177                     UniquePtr<Object> fromleft_value = stack.Pop();
 4178                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 4179                 }
 4180             }
 4181             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4182             {
 4183                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4184                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4185             }
 4186             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4187             {
 4188                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4189                 if (matched)
 4190                 {
 4191                     UniquePtr<Object> fromright_value = stack.Pop();
 4192                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 4193                 }
 4194             }
 4195             public class Context : System.Text.Parsing.Context
 4196             {
 4197                 public Context() : context(), result(), value(), fromleft(), fromright()
 4198                 {
 4199                 }
 4200                 public cmsx.intermediate.Context* context;
 4201                 public Value* result;
 4202                 public Instruction* value;
 4203                 public Value* fromleft;
 4204                 public Value* fromright;
 4205             }
 4206         }
 4207 
 4208         public class EqualInstructionRule : System.Text.Parsing.RuleParser
 4209         {
 4210             public EqualInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4211             {
 4212                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4213                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4214                 SetValueTypeName(ToUtf32("Instruction*"));
 4215             }
 4216             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4217             {
 4218                 parsingData->PushContext(Id(), new Context());
 4219                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4220                 UniquePtr<Object> result_value = stack.Pop();
 4221                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4222                 UniquePtr<Object> context_value = stack.Pop();
 4223                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4224             }
 4225             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4226             {
 4227                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4228                 if (matched)
 4229                 {
 4230                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4231                 }
 4232                 parsingData->PopContext(Id());
 4233             }
 4234             public override void Link()
 4235             {
 4236                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4237                 a0ActionParser->SetAction(A0Action);
 4238                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 4239                 leftNonterminalParser->SetPre(Preleft);
 4240                 leftNonterminalParser->SetPost(Postleft);
 4241                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 4242                 rightNonterminalParser->SetPre(Preright);
 4243                 rightNonterminalParser->SetPost(Postright);
 4244             }
 4245             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4246             {
 4247                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4248                 context->value = new EqualInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 4249             }
 4250             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4251             {
 4252                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4253                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4254             }
 4255             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4256             {
 4257                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4258                 if (matched)
 4259                 {
 4260                     UniquePtr<Object> fromleft_value = stack.Pop();
 4261                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 4262                 }
 4263             }
 4264             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4265             {
 4266                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4267                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4268             }
 4269             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4270             {
 4271                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4272                 if (matched)
 4273                 {
 4274                     UniquePtr<Object> fromright_value = stack.Pop();
 4275                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 4276                 }
 4277             }
 4278             public class Context : System.Text.Parsing.Context
 4279             {
 4280                 public Context() : context(), result(), value(), fromleft(), fromright()
 4281                 {
 4282                 }
 4283                 public cmsx.intermediate.Context* context;
 4284                 public Value* result;
 4285                 public Instruction* value;
 4286                 public Value* fromleft;
 4287                 public Value* fromright;
 4288             }
 4289         }
 4290 
 4291         public class LessInstructionRule : System.Text.Parsing.RuleParser
 4292         {
 4293             public LessInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4294             {
 4295                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4296                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4297                 SetValueTypeName(ToUtf32("Instruction*"));
 4298             }
 4299             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4300             {
 4301                 parsingData->PushContext(Id(), new Context());
 4302                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4303                 UniquePtr<Object> result_value = stack.Pop();
 4304                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4305                 UniquePtr<Object> context_value = stack.Pop();
 4306                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4307             }
 4308             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4309             {
 4310                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4311                 if (matched)
 4312                 {
 4313                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4314                 }
 4315                 parsingData->PopContext(Id());
 4316             }
 4317             public override void Link()
 4318             {
 4319                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4320                 a0ActionParser->SetAction(A0Action);
 4321                 NonterminalParser* leftNonterminalParser = GetNonterminal(ToUtf32("left"));
 4322                 leftNonterminalParser->SetPre(Preleft);
 4323                 leftNonterminalParser->SetPost(Postleft);
 4324                 NonterminalParser* rightNonterminalParser = GetNonterminal(ToUtf32("right"));
 4325                 rightNonterminalParser->SetPre(Preright);
 4326                 rightNonterminalParser->SetPost(Postright);
 4327             }
 4328             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4329             {
 4330                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4331                 context->value = new LessInstruction(context->result, context->fromleft, context->fromright, span.lineNumber);
 4332             }
 4333             public void Preleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4334             {
 4335                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4336                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4337             }
 4338             public void Postleft(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4339             {
 4340                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4341                 if (matched)
 4342                 {
 4343                     UniquePtr<Object> fromleft_value = stack.Pop();
 4344                     context->fromleft = *cast<ValueObject<Value*>*>(fromleft_value.Get());
 4345                 }
 4346             }
 4347             public void Preright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4348             {
 4349                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4350                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4351             }
 4352             public void Postright(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4353             {
 4354                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4355                 if (matched)
 4356                 {
 4357                     UniquePtr<Object> fromright_value = stack.Pop();
 4358                     context->fromright = *cast<ValueObject<Value*>*>(fromright_value.Get());
 4359                 }
 4360             }
 4361             public class Context : System.Text.Parsing.Context
 4362             {
 4363                 public Context() : context(), result(), value(), fromleft(), fromright()
 4364                 {
 4365                 }
 4366                 public cmsx.intermediate.Context* context;
 4367                 public Value* result;
 4368                 public Instruction* value;
 4369                 public Value* fromleft;
 4370                 public Value* fromright;
 4371             }
 4372         }
 4373 
 4374         public class ParamInstructionRule : System.Text.Parsing.RuleParser
 4375         {
 4376             public ParamInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4377             {
 4378                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4379                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4380                 SetValueTypeName(ToUtf32("Instruction*"));
 4381             }
 4382             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4383             {
 4384                 parsingData->PushContext(Id(), new Context());
 4385                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4386                 UniquePtr<Object> result_value = stack.Pop();
 4387                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4388                 UniquePtr<Object> context_value = stack.Pop();
 4389                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4390             }
 4391             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4392             {
 4393                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4394                 if (matched)
 4395                 {
 4396                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4397                 }
 4398                 parsingData->PopContext(Id());
 4399             }
 4400             public override void Link()
 4401             {
 4402                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4403                 a0ActionParser->SetAction(A0Action);
 4404             }
 4405             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4406             {
 4407                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4408                 context->value = new ParamInstruction(context->result, span.lineNumber);
 4409             }
 4410             public class Context : System.Text.Parsing.Context
 4411             {
 4412                 public Context() : context(), result(), value()
 4413                 {
 4414                 }
 4415                 public cmsx.intermediate.Context* context;
 4416                 public Value* result;
 4417                 public Instruction* value;
 4418             }
 4419         }
 4420 
 4421         public class LocalInstructionRule : System.Text.Parsing.RuleParser
 4422         {
 4423             public LocalInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4424             {
 4425                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4426                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4427                 SetValueTypeName(ToUtf32("Instruction*"));
 4428             }
 4429             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4430             {
 4431                 parsingData->PushContext(Id(), new Context());
 4432                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4433                 UniquePtr<Object> result_value = stack.Pop();
 4434                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4435                 UniquePtr<Object> context_value = stack.Pop();
 4436                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4437             }
 4438             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4439             {
 4440                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4441                 if (matched)
 4442                 {
 4443                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4444                 }
 4445                 parsingData->PopContext(Id());
 4446             }
 4447             public override void Link()
 4448             {
 4449                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4450                 a0ActionParser->SetAction(A0Action);
 4451                 NonterminalParser* localTypeNonterminalParser = GetNonterminal(ToUtf32("localType"));
 4452                 localTypeNonterminalParser->SetPre(PrelocalType);
 4453                 localTypeNonterminalParser->SetPost(PostlocalType);
 4454             }
 4455             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4456             {
 4457                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4458                 context->value = new LocalInstruction(context->result, context->fromlocalType, span.lineNumber);
 4459             }
 4460             public void PrelocalType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4461             {
 4462                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4463                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4464             }
 4465             public void PostlocalType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4466             {
 4467                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4468                 if (matched)
 4469                 {
 4470                     UniquePtr<Object> fromlocalType_value = stack.Pop();
 4471                     context->fromlocalType = *cast<ValueObject<Type*>*>(fromlocalType_value.Get());
 4472                 }
 4473             }
 4474             public class Context : System.Text.Parsing.Context
 4475             {
 4476                 public Context() : context(), result(), value(), fromlocalType()
 4477                 {
 4478                 }
 4479                 public cmsx.intermediate.Context* context;
 4480                 public Value* result;
 4481                 public Instruction* value;
 4482                 public Type* fromlocalType;
 4483             }
 4484         }
 4485 
 4486         public class LoadInstructionRule : System.Text.Parsing.RuleParser
 4487         {
 4488             public LoadInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4489             {
 4490                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4491                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4492                 SetValueTypeName(ToUtf32("Instruction*"));
 4493             }
 4494             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4495             {
 4496                 parsingData->PushContext(Id(), new Context());
 4497                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4498                 UniquePtr<Object> result_value = stack.Pop();
 4499                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4500                 UniquePtr<Object> context_value = stack.Pop();
 4501                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4502             }
 4503             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4504             {
 4505                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4506                 if (matched)
 4507                 {
 4508                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4509                 }
 4510                 parsingData->PopContext(Id());
 4511             }
 4512             public override void Link()
 4513             {
 4514                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4515                 a0ActionParser->SetAction(A0Action);
 4516                 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
 4517                 ptrNonterminalParser->SetPre(Preptr);
 4518                 ptrNonterminalParser->SetPost(Postptr);
 4519             }
 4520             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4521             {
 4522                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4523                 context->value = new LoadInstruction(context->result, context->fromptr, span.lineNumber);
 4524             }
 4525             public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4526             {
 4527                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4528                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4529             }
 4530             public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4531             {
 4532                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4533                 if (matched)
 4534                 {
 4535                     UniquePtr<Object> fromptr_value = stack.Pop();
 4536                     context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
 4537                 }
 4538             }
 4539             public class Context : System.Text.Parsing.Context
 4540             {
 4541                 public Context() : context(), result(), value(), fromptr()
 4542                 {
 4543                 }
 4544                 public cmsx.intermediate.Context* context;
 4545                 public Value* result;
 4546                 public Instruction* value;
 4547                 public Value* fromptr;
 4548             }
 4549         }
 4550 
 4551         public class ElemAddrInstructionRule : System.Text.Parsing.RuleParser
 4552         {
 4553             public ElemAddrInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4554             {
 4555                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4556                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4557                 SetValueTypeName(ToUtf32("Instruction*"));
 4558             }
 4559             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4560             {
 4561                 parsingData->PushContext(Id(), new Context());
 4562                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4563                 UniquePtr<Object> result_value = stack.Pop();
 4564                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4565                 UniquePtr<Object> context_value = stack.Pop();
 4566                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4567             }
 4568             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4569             {
 4570                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4571                 if (matched)
 4572                 {
 4573                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4574                 }
 4575                 parsingData->PopContext(Id());
 4576             }
 4577             public override void Link()
 4578             {
 4579                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4580                 a0ActionParser->SetAction(A0Action);
 4581                 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
 4582                 ptrNonterminalParser->SetPre(Preptr);
 4583                 ptrNonterminalParser->SetPost(Postptr);
 4584                 NonterminalParser* indexNonterminalParser = GetNonterminal(ToUtf32("index"));
 4585                 indexNonterminalParser->SetPre(Preindex);
 4586                 indexNonterminalParser->SetPost(Postindex);
 4587             }
 4588             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4589             {
 4590                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4591                 context->value = new ElemAddrInstruction(context->result, context->fromptr, context->fromindex, span.lineNumber);
 4592             }
 4593             public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4594             {
 4595                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4596                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4597             }
 4598             public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4599             {
 4600                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4601                 if (matched)
 4602                 {
 4603                     UniquePtr<Object> fromptr_value = stack.Pop();
 4604                     context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
 4605                 }
 4606             }
 4607             public void Preindex(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4608             {
 4609                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4610                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4611             }
 4612             public void Postindex(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4613             {
 4614                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4615                 if (matched)
 4616                 {
 4617                     UniquePtr<Object> fromindex_value = stack.Pop();
 4618                     context->fromindex = *cast<ValueObject<Value*>*>(fromindex_value.Get());
 4619                 }
 4620             }
 4621             public class Context : System.Text.Parsing.Context
 4622             {
 4623                 public Context() : context(), result(), value(), fromptr(), fromindex()
 4624                 {
 4625                 }
 4626                 public cmsx.intermediate.Context* context;
 4627                 public Value* result;
 4628                 public Instruction* value;
 4629                 public Value* fromptr;
 4630                 public Value* fromindex;
 4631             }
 4632         }
 4633 
 4634         public class PtrOffsetInstructionRule : System.Text.Parsing.RuleParser
 4635         {
 4636             public PtrOffsetInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4637             {
 4638                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4639                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4640                 SetValueTypeName(ToUtf32("Instruction*"));
 4641             }
 4642             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4643             {
 4644                 parsingData->PushContext(Id(), new Context());
 4645                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4646                 UniquePtr<Object> result_value = stack.Pop();
 4647                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4648                 UniquePtr<Object> context_value = stack.Pop();
 4649                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4650             }
 4651             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4652             {
 4653                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4654                 if (matched)
 4655                 {
 4656                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4657                 }
 4658                 parsingData->PopContext(Id());
 4659             }
 4660             public override void Link()
 4661             {
 4662                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4663                 a0ActionParser->SetAction(A0Action);
 4664                 NonterminalParser* ptrNonterminalParser = GetNonterminal(ToUtf32("ptr"));
 4665                 ptrNonterminalParser->SetPre(Preptr);
 4666                 ptrNonterminalParser->SetPost(Postptr);
 4667                 NonterminalParser* offsetNonterminalParser = GetNonterminal(ToUtf32("offset"));
 4668                 offsetNonterminalParser->SetPre(Preoffset);
 4669                 offsetNonterminalParser->SetPost(Postoffset);
 4670             }
 4671             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4672             {
 4673                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4674                 context->value = new PtrOffsetInstruction(context->result, context->fromptr, context->fromoffset, span.lineNumber);
 4675             }
 4676             public void Preptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4677             {
 4678                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4679                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4680             }
 4681             public void Postptr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4682             {
 4683                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4684                 if (matched)
 4685                 {
 4686                     UniquePtr<Object> fromptr_value = stack.Pop();
 4687                     context->fromptr = *cast<ValueObject<Value*>*>(fromptr_value.Get());
 4688                 }
 4689             }
 4690             public void Preoffset(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4691             {
 4692                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4693                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4694             }
 4695             public void Postoffset(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4696             {
 4697                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4698                 if (matched)
 4699                 {
 4700                     UniquePtr<Object> fromoffset_value = stack.Pop();
 4701                     context->fromoffset = *cast<ValueObject<Value*>*>(fromoffset_value.Get());
 4702                 }
 4703             }
 4704             public class Context : System.Text.Parsing.Context
 4705             {
 4706                 public Context() : context(), result(), value(), fromptr(), fromoffset()
 4707                 {
 4708                 }
 4709                 public cmsx.intermediate.Context* context;
 4710                 public Value* result;
 4711                 public Instruction* value;
 4712                 public Value* fromptr;
 4713                 public Value* fromoffset;
 4714             }
 4715         }
 4716 
 4717         public class PtrDiffInstructionRule : System.Text.Parsing.RuleParser
 4718         {
 4719             public PtrDiffInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4720             {
 4721                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4722                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4723                 SetValueTypeName(ToUtf32("Instruction*"));
 4724             }
 4725             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4726             {
 4727                 parsingData->PushContext(Id(), new Context());
 4728                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4729                 UniquePtr<Object> result_value = stack.Pop();
 4730                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4731                 UniquePtr<Object> context_value = stack.Pop();
 4732                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4733             }
 4734             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4735             {
 4736                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4737                 if (matched)
 4738                 {
 4739                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4740                 }
 4741                 parsingData->PopContext(Id());
 4742             }
 4743             public override void Link()
 4744             {
 4745                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4746                 a0ActionParser->SetAction(A0Action);
 4747                 NonterminalParser* leftPtrNonterminalParser = GetNonterminal(ToUtf32("leftPtr"));
 4748                 leftPtrNonterminalParser->SetPre(PreleftPtr);
 4749                 leftPtrNonterminalParser->SetPost(PostleftPtr);
 4750                 NonterminalParser* rightPtrNonterminalParser = GetNonterminal(ToUtf32("rightPtr"));
 4751                 rightPtrNonterminalParser->SetPre(PrerightPtr);
 4752                 rightPtrNonterminalParser->SetPost(PostrightPtr);
 4753             }
 4754             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4755             {
 4756                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4757                 context->value = new PtrDiffInstruction(context->result, context->fromleftPtr, context->fromrightPtr, span.lineNumber);
 4758             }
 4759             public void PreleftPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4760             {
 4761                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4762                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4763             }
 4764             public void PostleftPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4765             {
 4766                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4767                 if (matched)
 4768                 {
 4769                     UniquePtr<Object> fromleftPtr_value = stack.Pop();
 4770                     context->fromleftPtr = *cast<ValueObject<Value*>*>(fromleftPtr_value.Get());
 4771                 }
 4772             }
 4773             public void PrerightPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4774             {
 4775                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4776                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4777             }
 4778             public void PostrightPtr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4779             {
 4780                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4781                 if (matched)
 4782                 {
 4783                     UniquePtr<Object> fromrightPtr_value = stack.Pop();
 4784                     context->fromrightPtr = *cast<ValueObject<Value*>*>(fromrightPtr_value.Get());
 4785                 }
 4786             }
 4787             public class Context : System.Text.Parsing.Context
 4788             {
 4789                 public Context() : context(), result(), value(), fromleftPtr(), fromrightPtr()
 4790                 {
 4791                 }
 4792                 public cmsx.intermediate.Context* context;
 4793                 public Value* result;
 4794                 public Instruction* value;
 4795                 public Value* fromleftPtr;
 4796                 public Value* fromrightPtr;
 4797             }
 4798         }
 4799 
 4800         public class FunctionCallInstructionRule : System.Text.Parsing.RuleParser
 4801         {
 4802             public FunctionCallInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4803             {
 4804                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4805                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4806                 SetValueTypeName(ToUtf32("Instruction*"));
 4807             }
 4808             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4809             {
 4810                 parsingData->PushContext(Id(), new Context());
 4811                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4812                 UniquePtr<Object> result_value = stack.Pop();
 4813                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4814                 UniquePtr<Object> context_value = stack.Pop();
 4815                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4816             }
 4817             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4818             {
 4819                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4820                 if (matched)
 4821                 {
 4822                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4823                 }
 4824                 parsingData->PopContext(Id());
 4825             }
 4826             public override void Link()
 4827             {
 4828                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4829                 a0ActionParser->SetAction(A0Action);
 4830                 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("functionType"));
 4831                 functionTypeNonterminalParser->SetPre(PrefunctionType);
 4832                 functionTypeNonterminalParser->SetPost(PostfunctionType);
 4833                 NonterminalParser* calleeNonterminalParser = GetNonterminal(ToUtf32("callee"));
 4834                 calleeNonterminalParser->SetPre(Precallee);
 4835                 calleeNonterminalParser->SetPost(Postcallee);
 4836             }
 4837             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4838             {
 4839                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4840                 context->value = new FunctionCallInstruction(context->result, context->fromcallee, span.lineNumber);
 4841             }
 4842             public void PrefunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4843             {
 4844                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4845                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4846             }
 4847             public void PostfunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4848             {
 4849                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4850                 if (matched)
 4851                 {
 4852                     UniquePtr<Object> fromfunctionType_value = stack.Pop();
 4853                     context->fromfunctionType = *cast<ValueObject<Type*>*>(fromfunctionType_value.Get());
 4854                 }
 4855             }
 4856             public void Precallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4857             {
 4858                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4859                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4860                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromfunctionType)));
 4861             }
 4862             public void Postcallee(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4863             {
 4864                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4865                 if (matched)
 4866                 {
 4867                     UniquePtr<Object> fromcallee_value = stack.Pop();
 4868                     context->fromcallee = *cast<ValueObject<Value*>*>(fromcallee_value.Get());
 4869                 }
 4870             }
 4871             public class Context : System.Text.Parsing.Context
 4872             {
 4873                 public Context() : context(), result(), value(), fromfunctionType(), fromcallee()
 4874                 {
 4875                 }
 4876                 public cmsx.intermediate.Context* context;
 4877                 public Value* result;
 4878                 public Instruction* value;
 4879                 public Type* fromfunctionType;
 4880                 public Value* fromcallee;
 4881             }
 4882         }
 4883 
 4884         public class TrapInstructionRule : System.Text.Parsing.RuleParser
 4885         {
 4886             public TrapInstructionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 4887             {
 4888                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 4889                 AddInheritedAttribute(AttrOrVar(ToUtf32("Value*"), ToUtf32("result")));
 4890                 SetValueTypeName(ToUtf32("Instruction*"));
 4891             }
 4892             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4893             {
 4894                 parsingData->PushContext(Id(), new Context());
 4895                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4896                 UniquePtr<Object> result_value = stack.Pop();
 4897                 context->result = *cast<ValueObject<Value*>*>(result_value.Get());
 4898                 UniquePtr<Object> context_value = stack.Pop();
 4899                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 4900             }
 4901             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4902             {
 4903                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4904                 if (matched)
 4905                 {
 4906                     stack.Push(UniquePtr<Object>(new ValueObject<Instruction*>(context->value)));
 4907                 }
 4908                 parsingData->PopContext(Id());
 4909             }
 4910             public override void Link()
 4911             {
 4912                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 4913                 a0ActionParser->SetAction(A0Action);
 4914                 NonterminalParser* type1NonterminalParser = GetNonterminal(ToUtf32("type1"));
 4915                 type1NonterminalParser->SetPre(Pretype1);
 4916                 type1NonterminalParser->SetPost(Posttype1);
 4917                 NonterminalParser* val1NonterminalParser = GetNonterminal(ToUtf32("val1"));
 4918                 val1NonterminalParser->SetPre(Preval1);
 4919                 val1NonterminalParser->SetPost(Postval1);
 4920                 NonterminalParser* type2NonterminalParser = GetNonterminal(ToUtf32("type2"));
 4921                 type2NonterminalParser->SetPre(Pretype2);
 4922                 type2NonterminalParser->SetPost(Posttype2);
 4923                 NonterminalParser* val2NonterminalParser = GetNonterminal(ToUtf32("val2"));
 4924                 val2NonterminalParser->SetPre(Preval2);
 4925                 val2NonterminalParser->SetPost(Postval2);
 4926                 NonterminalParser* type3NonterminalParser = GetNonterminal(ToUtf32("type3"));
 4927                 type3NonterminalParser->SetPre(Pretype3);
 4928                 type3NonterminalParser->SetPost(Posttype3);
 4929                 NonterminalParser* val3NonterminalParser = GetNonterminal(ToUtf32("val3"));
 4930                 val3NonterminalParser->SetPre(Preval3);
 4931                 val3NonterminalParser->SetPost(Postval3);
 4932             }
 4933             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 4934             {
 4935                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4936                 context->value = new TrapInstruction(context->result, context->fromval1, context->fromval2, context->fromval3, span.lineNumber);
 4937             }
 4938             public void Pretype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4939             {
 4940                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4941                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4942             }
 4943             public void Posttype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4944             {
 4945                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4946                 if (matched)
 4947                 {
 4948                     UniquePtr<Object> fromtype1_value = stack.Pop();
 4949                     context->fromtype1 = *cast<ValueObject<Type*>*>(fromtype1_value.Get());
 4950                 }
 4951             }
 4952             public void Preval1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4953             {
 4954                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4955                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4956                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype1)));
 4957             }
 4958             public void Postval1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4959             {
 4960                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4961                 if (matched)
 4962                 {
 4963                     UniquePtr<Object> fromval1_value = stack.Pop();
 4964                     context->fromval1 = *cast<ValueObject<Value*>*>(fromval1_value.Get());
 4965                 }
 4966             }
 4967             public void Pretype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4968             {
 4969                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4970                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4971             }
 4972             public void Posttype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4973             {
 4974                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4975                 if (matched)
 4976                 {
 4977                     UniquePtr<Object> fromtype2_value = stack.Pop();
 4978                     context->fromtype2 = *cast<ValueObject<Type*>*>(fromtype2_value.Get());
 4979                 }
 4980             }
 4981             public void Preval2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4982             {
 4983                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4984                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 4985                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype2)));
 4986             }
 4987             public void Postval2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 4988             {
 4989                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4990                 if (matched)
 4991                 {
 4992                     UniquePtr<Object> fromval2_value = stack.Pop();
 4993                     context->fromval2 = *cast<ValueObject<Value*>*>(fromval2_value.Get());
 4994                 }
 4995             }
 4996             public void Pretype3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 4997             {
 4998                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 4999                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5000             }
 5001             public void Posttype3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5002             {
 5003                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5004                 if (matched)
 5005                 {
 5006                     UniquePtr<Object> fromtype3_value = stack.Pop();
 5007                     context->fromtype3 = *cast<ValueObject<Type*>*>(fromtype3_value.Get());
 5008                 }
 5009             }
 5010             public void Preval3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5011             {
 5012                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5013                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5014                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype3)));
 5015             }
 5016             public void Postval3(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5017             {
 5018                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5019                 if (matched)
 5020                 {
 5021                     UniquePtr<Object> fromval3_value = stack.Pop();
 5022                     context->fromval3 = *cast<ValueObject<Value*>*>(fromval3_value.Get());
 5023                 }
 5024             }
 5025             public class Context : System.Text.Parsing.Context
 5026             {
 5027                 public Context() : context(), result(), value(), fromtype1(), fromval1(), fromtype2(), fromval2(), fromtype3(), fromval3()
 5028                 {
 5029                 }
 5030                 public cmsx.intermediate.Context* context;
 5031                 public Value* result;
 5032                 public Instruction* value;
 5033                 public Type* fromtype1;
 5034                 public Value* fromval1;
 5035                 public Type* fromtype2;
 5036                 public Value* fromval2;
 5037                 public Type* fromtype3;
 5038                 public Value* fromval3;
 5039             }
 5040         }
 5041 
 5042         public class OperandRule : System.Text.Parsing.RuleParser
 5043         {
 5044             public OperandRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5045             {
 5046                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5047                 SetValueTypeName(ToUtf32("Value*"));
 5048             }
 5049             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5050             {
 5051                 parsingData->PushContext(Id(), new Context());
 5052                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5053                 UniquePtr<Object> context_value = stack.Pop();
 5054                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5055             }
 5056             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5057             {
 5058                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5059                 if (matched)
 5060                 {
 5061                     stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
 5062                 }
 5063                 parsingData->PopContext(Id());
 5064             }
 5065             public override void Link()
 5066             {
 5067                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5068                 a0ActionParser->SetAction(A0Action);
 5069                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 5070                 typeNonterminalParser->SetPre(Pretype);
 5071                 typeNonterminalParser->SetPost(Posttype);
 5072                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 5073                 valNonterminalParser->SetPre(Preval);
 5074                 valNonterminalParser->SetPost(Postval);
 5075             }
 5076             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5077             {
 5078                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5079                 context->value = context->fromval;
 5080             }
 5081             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5082             {
 5083                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5084                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5085             }
 5086             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5087             {
 5088                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5089                 if (matched)
 5090                 {
 5091                     UniquePtr<Object> fromtype_value = stack.Pop();
 5092                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 5093                 }
 5094             }
 5095             public void Preval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5096             {
 5097                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5098                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5099                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 5100             }
 5101             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5102             {
 5103                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5104                 if (matched)
 5105                 {
 5106                     UniquePtr<Object> fromval_value = stack.Pop();
 5107                     context->fromval = *cast<ValueObject<Value*>*>(fromval_value.Get());
 5108                 }
 5109             }
 5110             public class Context : System.Text.Parsing.Context
 5111             {
 5112                 public Context() : context(), value(), fromtype(), fromval()
 5113                 {
 5114                 }
 5115                 public cmsx.intermediate.Context* context;
 5116                 public Value* value;
 5117                 public Type* fromtype;
 5118                 public Value* fromval;
 5119             }
 5120         }
 5121 
 5122         public class LabelRule : System.Text.Parsing.RuleParser
 5123         {
 5124             public LabelRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5125             {
 5126                 SetValueTypeName(ToUtf32("uint"));
 5127             }
 5128             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5129             {
 5130                 parsingData->PushContext(Id(), new Context());
 5131                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5132             }
 5133             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5134             {
 5135                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5136                 if (matched)
 5137                 {
 5138                     stack.Push(UniquePtr<Object>(new ValueObject<uint>(context->value)));
 5139                 }
 5140                 parsingData->PopContext(Id());
 5141             }
 5142             public override void Link()
 5143             {
 5144                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5145                 a0ActionParser->SetAction(A0Action);
 5146                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 5147                 xNonterminalParser->SetPost(Postx);
 5148             }
 5149             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5150             {
 5151                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5152                 context->value = context->fromx;
 5153             }
 5154             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5155             {
 5156                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5157                 if (matched)
 5158                 {
 5159                     UniquePtr<Object> fromx_value = stack.Pop();
 5160                     context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
 5161                 }
 5162             }
 5163             public class Context : System.Text.Parsing.Context
 5164             {
 5165                 public Context() : value(), fromx()
 5166                 {
 5167                 }
 5168                 public uint value;
 5169                 public uint fromx;
 5170             }
 5171         }
 5172 
 5173         public class ValueRule : System.Text.Parsing.RuleParser
 5174         {
 5175             public ValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5176             {
 5177                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5178                 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
 5179                 SetValueTypeName(ToUtf32("Value*"));
 5180             }
 5181             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5182             {
 5183                 parsingData->PushContext(Id(), new Context());
 5184                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5185                 UniquePtr<Object> type_value = stack.Pop();
 5186                 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
 5187                 UniquePtr<Object> context_value = stack.Pop();
 5188                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5189             }
 5190             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5191             {
 5192                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5193                 if (matched)
 5194                 {
 5195                     stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
 5196                 }
 5197                 parsingData->PopContext(Id());
 5198             }
 5199             public override void Link()
 5200             {
 5201                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5202                 a0ActionParser->SetAction(A0Action);
 5203                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 5204                 a1ActionParser->SetAction(A1Action);
 5205                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 5206                 a2ActionParser->SetAction(A2Action);
 5207                 NonterminalParser* idValueNonterminalParser = GetNonterminal(ToUtf32("IdValue"));
 5208                 idValueNonterminalParser->SetPre(PreIdValue);
 5209                 idValueNonterminalParser->SetPost(PostIdValue);
 5210                 NonterminalParser* symbolValueNonterminalParser = GetNonterminal(ToUtf32("SymbolValue"));
 5211                 symbolValueNonterminalParser->SetPre(PreSymbolValue);
 5212                 symbolValueNonterminalParser->SetPost(PostSymbolValue);
 5213                 NonterminalParser* literalValueNonterminalParser = GetNonterminal(ToUtf32("LiteralValue"));
 5214                 literalValueNonterminalParser->SetPre(PreLiteralValue);
 5215                 literalValueNonterminalParser->SetPost(PostLiteralValue);
 5216             }
 5217             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5218             {
 5219                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5220                 context->value = context->fromIdValue;
 5221             }
 5222             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5223             {
 5224                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5225                 context->value = context->fromSymbolValue;
 5226             }
 5227             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5228             {
 5229                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5230                 context->value = context->fromLiteralValue;
 5231             }
 5232             public void PreIdValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5233             {
 5234                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5235                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5236                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
 5237             }
 5238             public void PostIdValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5239             {
 5240                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5241                 if (matched)
 5242                 {
 5243                     UniquePtr<Object> fromIdValue_value = stack.Pop();
 5244                     context->fromIdValue = *cast<ValueObject<Value*>*>(fromIdValue_value.Get());
 5245                 }
 5246             }
 5247             public void PreSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5248             {
 5249                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5250                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5251                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
 5252             }
 5253             public void PostSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5254             {
 5255                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5256                 if (matched)
 5257                 {
 5258                     UniquePtr<Object> fromSymbolValue_value = stack.Pop();
 5259                     context->fromSymbolValue = *cast<ValueObject<ConstantValue*>*>(fromSymbolValue_value.Get());
 5260                 }
 5261             }
 5262             public void PreLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5263             {
 5264                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5265                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5266                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->type)));
 5267             }
 5268             public void PostLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5269             {
 5270                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5271                 if (matched)
 5272                 {
 5273                     UniquePtr<Object> fromLiteralValue_value = stack.Pop();
 5274                     context->fromLiteralValue = *cast<ValueObject<ConstantValue*>*>(fromLiteralValue_value.Get());
 5275                 }
 5276             }
 5277             public class Context : System.Text.Parsing.Context
 5278             {
 5279                 public Context() : context(), type(), value(), fromIdValue(), fromSymbolValue(), fromLiteralValue()
 5280                 {
 5281                 }
 5282                 public cmsx.intermediate.Context* context;
 5283                 public Type* type;
 5284                 public Value* value;
 5285                 public Value* fromIdValue;
 5286                 public ConstantValue* fromSymbolValue;
 5287                 public ConstantValue* fromLiteralValue;
 5288             }
 5289         }
 5290 
 5291         public class IdValueRule : System.Text.Parsing.RuleParser
 5292         {
 5293             public IdValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5294             {
 5295                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5296                 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
 5297                 SetValueTypeName(ToUtf32("Value*"));
 5298             }
 5299             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5300             {
 5301                 parsingData->PushContext(Id(), new Context());
 5302                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5303                 UniquePtr<Object> type_value = stack.Pop();
 5304                 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
 5305                 UniquePtr<Object> context_value = stack.Pop();
 5306                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5307             }
 5308             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5309             {
 5310                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5311                 if (matched)
 5312                 {
 5313                     stack.Push(UniquePtr<Object>(new ValueObject<Value*>(context->value)));
 5314                 }
 5315                 parsingData->PopContext(Id());
 5316             }
 5317             public override void Link()
 5318             {
 5319                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5320                 a0ActionParser->SetAction(A0Action);
 5321                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 5322                 xNonterminalParser->SetPost(Postx);
 5323             }
 5324             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5325             {
 5326                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5327                 context->value = context->context->currentFunction->MakeIdValue(span.lineNumber, context->fromx, context->type);
 5328             }
 5329             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5330             {
 5331                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5332                 if (matched)
 5333                 {
 5334                     UniquePtr<Object> fromx_value = stack.Pop();
 5335                     context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
 5336                 }
 5337             }
 5338             public class Context : System.Text.Parsing.Context
 5339             {
 5340                 public Context() : context(), type(), value(), fromx()
 5341                 {
 5342                 }
 5343                 public cmsx.intermediate.Context* context;
 5344                 public Type* type;
 5345                 public Value* value;
 5346                 public uint fromx;
 5347             }
 5348         }
 5349 
 5350         public class SymbolValueRule : System.Text.Parsing.RuleParser
 5351         {
 5352             public SymbolValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5353             {
 5354                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5355                 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
 5356                 SetValueTypeName(ToUtf32("ConstantValue*"));
 5357             }
 5358             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5359             {
 5360                 parsingData->PushContext(Id(), new Context());
 5361                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5362                 UniquePtr<Object> type_value = stack.Pop();
 5363                 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
 5364                 UniquePtr<Object> context_value = stack.Pop();
 5365                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5366             }
 5367             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5368             {
 5369                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5370                 if (matched)
 5371                 {
 5372                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 5373                 }
 5374                 parsingData->PopContext(Id());
 5375             }
 5376             public override void Link()
 5377             {
 5378                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5379                 a0ActionParser->SetAction(A0Action);
 5380                 NonterminalParser* identifierNonterminalParser = GetNonterminal(ToUtf32("identifier"));
 5381                 identifierNonterminalParser->SetPost(Postidentifier);
 5382             }
 5383             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5384             {
 5385                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5386                 context->value = context->context->MakeSymbolValue(span.lineNumber, ToUtf8(context->fromidentifier), context->type);
 5387             }
 5388             public void Postidentifier(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5389             {
 5390                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5391                 if (matched)
 5392                 {
 5393                     UniquePtr<Object> fromidentifier_value = stack.Pop();
 5394                     context->fromidentifier = *cast<ValueObject<ustring>*>(fromidentifier_value.Get());
 5395                 }
 5396             }
 5397             public class Context : System.Text.Parsing.Context
 5398             {
 5399                 public Context() : context(), type(), value(), fromidentifier()
 5400                 {
 5401                 }
 5402                 public cmsx.intermediate.Context* context;
 5403                 public Type* type;
 5404                 public ConstantValue* value;
 5405                 public ustring fromidentifier;
 5406             }
 5407         }
 5408 
 5409         public class LiteralValueRule : System.Text.Parsing.RuleParser
 5410         {
 5411             public LiteralValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5412             {
 5413                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5414                 AddInheritedAttribute(AttrOrVar(ToUtf32("Type*"), ToUtf32("type")));
 5415                 SetValueTypeName(ToUtf32("ConstantValue*"));
 5416             }
 5417             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5418             {
 5419                 parsingData->PushContext(Id(), new Context());
 5420                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5421                 UniquePtr<Object> type_value = stack.Pop();
 5422                 context->type = *cast<ValueObject<Type*>*>(type_value.Get());
 5423                 UniquePtr<Object> context_value = stack.Pop();
 5424                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5425             }
 5426             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5427             {
 5428                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5429                 if (matched)
 5430                 {
 5431                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 5432                 }
 5433                 parsingData->PopContext(Id());
 5434             }
 5435             public override void Link()
 5436             {
 5437                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5438                 a0ActionParser->SetAction(A0Action);
 5439             }
 5440             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5441             {
 5442                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5443                 context->value = context->context->MakeLiteralValue(span.lineNumber, ToUtf8(ustring(matchBegin, matchEnd)), context->type);
 5444             }
 5445             public class Context : System.Text.Parsing.Context
 5446             {
 5447                 public Context() : context(), type(), value()
 5448                 {
 5449                 }
 5450                 public cmsx.intermediate.Context* context;
 5451                 public Type* type;
 5452                 public ConstantValue* value;
 5453             }
 5454         }
 5455 
 5456         public class VariableNameRule : System.Text.Parsing.RuleParser
 5457         {
 5458             public VariableNameRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5459             {
 5460                 SetValueTypeName(ToUtf32("ustring"));
 5461             }
 5462             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5463             {
 5464                 parsingData->PushContext(Id(), new Context());
 5465                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5466             }
 5467             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5468             {
 5469                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5470                 if (matched)
 5471                 {
 5472                     stack.Push(UniquePtr<Object>(new ValueObject<ustring>(context->value)));
 5473                 }
 5474                 parsingData->PopContext(Id());
 5475             }
 5476             public override void Link()
 5477             {
 5478                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5479                 a0ActionParser->SetAction(A0Action);
 5480             }
 5481             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5482             {
 5483                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5484                 context->value = ustring(matchBegin, matchEnd);
 5485             }
 5486             public class Context : System.Text.Parsing.Context
 5487             {
 5488                 public Context() : value()
 5489                 {
 5490                 }
 5491                 public ustring value;
 5492             }
 5493         }
 5494 
 5495         public class TypeDeclarationRule : System.Text.Parsing.RuleParser
 5496         {
 5497             public TypeDeclarationRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5498             {
 5499                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5500             }
 5501             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5502             {
 5503                 parsingData->PushContext(Id(), new Context());
 5504                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5505                 UniquePtr<Object> context_value = stack.Pop();
 5506                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5507             }
 5508             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5509             {
 5510                 parsingData->PopContext(Id());
 5511             }
 5512             public override void Link()
 5513             {
 5514                 NonterminalParser* typeIdNonterminalParser = GetNonterminal(ToUtf32("typeId"));
 5515                 typeIdNonterminalParser->SetPre(PretypeId);
 5516                 typeIdNonterminalParser->SetPost(PosttypeId);
 5517                 NonterminalParser* structureTypeNonterminalParser = GetNonterminal(ToUtf32("StructureType"));
 5518                 structureTypeNonterminalParser->SetPre(PreStructureType);
 5519                 NonterminalParser* arrayTypeNonterminalParser = GetNonterminal(ToUtf32("ArrayType"));
 5520                 arrayTypeNonterminalParser->SetPre(PreArrayType);
 5521                 NonterminalParser* functionTypeNonterminalParser = GetNonterminal(ToUtf32("FunctionType"));
 5522                 functionTypeNonterminalParser->SetPre(PreFunctionType);
 5523             }
 5524             public void PretypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5525             {
 5526                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5527                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5528             }
 5529             public void PosttypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5530             {
 5531                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5532                 if (matched)
 5533                 {
 5534                     UniquePtr<Object> fromtypeId_value = stack.Pop();
 5535                     context->fromtypeId = *cast<ValueObject<string>*>(fromtypeId_value.Get());
 5536                 }
 5537             }
 5538             public void PreStructureType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5539             {
 5540                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5541                 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
 5542                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5543             }
 5544             public void PreArrayType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5545             {
 5546                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5547                 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
 5548                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5549             }
 5550             public void PreFunctionType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5551             {
 5552                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5553                 stack.Push(UniquePtr<Object>(new ValueObject<string>(context->fromtypeId)));
 5554                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5555             }
 5556             public class Context : System.Text.Parsing.Context
 5557             {
 5558                 public Context() : context(), fromtypeId()
 5559                 {
 5560                 }
 5561                 public cmsx.intermediate.Context* context;
 5562                 public string fromtypeId;
 5563             }
 5564         }
 5565 
 5566         public class StructureTypeRule : System.Text.Parsing.RuleParser
 5567         {
 5568             public StructureTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5569             {
 5570                 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
 5571                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5572                 AddLocalVariable(AttrOrVar(ToUtf32("List<string>"), ToUtf32("memberTypeIds")));
 5573             }
 5574             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5575             {
 5576                 parsingData->PushContext(Id(), new Context());
 5577                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5578                 UniquePtr<Object> context_value = stack.Pop();
 5579                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5580                 UniquePtr<Object> typeId_value = stack.Pop();
 5581                 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
 5582             }
 5583             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5584             {
 5585                 parsingData->PopContext(Id());
 5586             }
 5587             public override void Link()
 5588             {
 5589                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5590                 a0ActionParser->SetAction(A0Action);
 5591                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 5592                 a1ActionParser->SetAction(A1Action);
 5593                 NonterminalParser* strTypeIdNonterminalParser = GetNonterminal(ToUtf32("StrTypeId"));
 5594                 strTypeIdNonterminalParser->SetPre(PreStrTypeId);
 5595                 strTypeIdNonterminalParser->SetPost(PostStrTypeId);
 5596                 NonterminalParser* longNonterminalParser = GetNonterminal(ToUtf32("long"));
 5597                 longNonterminalParser->SetPost(Postlong);
 5598                 NonterminalParser* szNonterminalParser = GetNonterminal(ToUtf32("sz"));
 5599                 szNonterminalParser->SetPost(Postsz);
 5600                 NonterminalParser* alNonterminalParser = GetNonterminal(ToUtf32("al"));
 5601                 alNonterminalParser->SetPost(Postal);
 5602             }
 5603             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5604             {
 5605                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5606                 context->context->AddStructureType(context->typeId, context->memberTypeIds);
 5607             }
 5608             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5609             {
 5610                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5611                 context->memberTypeIds.Add(context->fromStrTypeId);
 5612             }
 5613             public void PreStrTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5614             {
 5615                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5616                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5617             }
 5618             public void PostStrTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5619             {
 5620                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5621                 if (matched)
 5622                 {
 5623                     UniquePtr<Object> fromStrTypeId_value = stack.Pop();
 5624                     context->fromStrTypeId = *cast<ValueObject<string>*>(fromStrTypeId_value.Get());
 5625                 }
 5626             }
 5627             public void Postlong(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5628             {
 5629                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5630                 if (matched)
 5631                 {
 5632                     UniquePtr<Object> fromlong_value = stack.Pop();
 5633                     context->fromlong = *cast<ValueObject<long>*>(fromlong_value.Get());
 5634                 }
 5635             }
 5636             public void Postsz(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5637             {
 5638                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5639                 if (matched)
 5640                 {
 5641                     UniquePtr<Object> fromsz_value = stack.Pop();
 5642                     context->fromsz = *cast<ValueObject<long>*>(fromsz_value.Get());
 5643                 }
 5644             }
 5645             public void Postal(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5646             {
 5647                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5648                 if (matched)
 5649                 {
 5650                     UniquePtr<Object> fromal_value = stack.Pop();
 5651                     context->fromal = *cast<ValueObject<long>*>(fromal_value.Get());
 5652                 }
 5653             }
 5654             public class Context : System.Text.Parsing.Context
 5655             {
 5656                 public Context() : typeId(), context(), memberTypeIds(), fromStrTypeId(), fromlong(), fromsz(), fromal()
 5657                 {
 5658                 }
 5659                 public string typeId;
 5660                 public cmsx.intermediate.Context* context;
 5661                 public List<string> memberTypeIds;
 5662                 public string fromStrTypeId;
 5663                 public long fromlong;
 5664                 public long fromsz;
 5665                 public long fromal;
 5666             }
 5667         }
 5668 
 5669         public class ArrayTypeRule : System.Text.Parsing.RuleParser
 5670         {
 5671             public ArrayTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5672             {
 5673                 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
 5674                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5675             }
 5676             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5677             {
 5678                 parsingData->PushContext(Id(), new Context());
 5679                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5680                 UniquePtr<Object> context_value = stack.Pop();
 5681                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5682                 UniquePtr<Object> typeId_value = stack.Pop();
 5683                 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
 5684             }
 5685             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5686             {
 5687                 parsingData->PopContext(Id());
 5688             }
 5689             public override void Link()
 5690             {
 5691                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5692                 a0ActionParser->SetAction(A0Action);
 5693                 NonterminalParser* sizeNonterminalParser = GetNonterminal(ToUtf32("size"));
 5694                 sizeNonterminalParser->SetPost(Postsize);
 5695                 NonterminalParser* elementTypeIdNonterminalParser = GetNonterminal(ToUtf32("elementTypeId"));
 5696                 elementTypeIdNonterminalParser->SetPre(PreelementTypeId);
 5697                 elementTypeIdNonterminalParser->SetPost(PostelementTypeId);
 5698                 NonterminalParser* szNonterminalParser = GetNonterminal(ToUtf32("sz"));
 5699                 szNonterminalParser->SetPost(Postsz);
 5700                 NonterminalParser* alNonterminalParser = GetNonterminal(ToUtf32("al"));
 5701                 alNonterminalParser->SetPost(Postal);
 5702             }
 5703             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5704             {
 5705                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5706                 context->context->AddArrayType(context->typeId, context->fromelementTypeId, context->fromsize);
 5707             }
 5708             public void Postsize(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5709             {
 5710                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5711                 if (matched)
 5712                 {
 5713                     UniquePtr<Object> fromsize_value = stack.Pop();
 5714                     context->fromsize = *cast<ValueObject<long>*>(fromsize_value.Get());
 5715                 }
 5716             }
 5717             public void PreelementTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5718             {
 5719                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5720                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5721             }
 5722             public void PostelementTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5723             {
 5724                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5725                 if (matched)
 5726                 {
 5727                     UniquePtr<Object> fromelementTypeId_value = stack.Pop();
 5728                     context->fromelementTypeId = *cast<ValueObject<string>*>(fromelementTypeId_value.Get());
 5729                 }
 5730             }
 5731             public void Postsz(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5732             {
 5733                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5734                 if (matched)
 5735                 {
 5736                     UniquePtr<Object> fromsz_value = stack.Pop();
 5737                     context->fromsz = *cast<ValueObject<long>*>(fromsz_value.Get());
 5738                 }
 5739             }
 5740             public void Postal(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5741             {
 5742                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5743                 if (matched)
 5744                 {
 5745                     UniquePtr<Object> fromal_value = stack.Pop();
 5746                     context->fromal = *cast<ValueObject<long>*>(fromal_value.Get());
 5747                 }
 5748             }
 5749             public class Context : System.Text.Parsing.Context
 5750             {
 5751                 public Context() : typeId(), context(), fromsize(), fromelementTypeId(), fromsz(), fromal()
 5752                 {
 5753                 }
 5754                 public string typeId;
 5755                 public cmsx.intermediate.Context* context;
 5756                 public long fromsize;
 5757                 public string fromelementTypeId;
 5758                 public long fromsz;
 5759                 public long fromal;
 5760             }
 5761         }
 5762 
 5763         public class FunctionTypeRule : System.Text.Parsing.RuleParser
 5764         {
 5765             public FunctionTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5766             {
 5767                 AddInheritedAttribute(AttrOrVar(ToUtf32("string"), ToUtf32("typeId")));
 5768                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5769                 AddLocalVariable(AttrOrVar(ToUtf32("List<string>"), ToUtf32("paramTypeIds")));
 5770             }
 5771             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5772             {
 5773                 parsingData->PushContext(Id(), new Context());
 5774                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5775                 UniquePtr<Object> context_value = stack.Pop();
 5776                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5777                 UniquePtr<Object> typeId_value = stack.Pop();
 5778                 context->typeId = *cast<ValueObject<string>*>(typeId_value.Get());
 5779             }
 5780             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5781             {
 5782                 parsingData->PopContext(Id());
 5783             }
 5784             public override void Link()
 5785             {
 5786                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5787                 a0ActionParser->SetAction(A0Action);
 5788                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 5789                 a1ActionParser->SetAction(A1Action);
 5790                 NonterminalParser* returnTypeIdNonterminalParser = GetNonterminal(ToUtf32("returnTypeId"));
 5791                 returnTypeIdNonterminalParser->SetPre(PrereturnTypeId);
 5792                 returnTypeIdNonterminalParser->SetPost(PostreturnTypeId);
 5793                 NonterminalParser* paramTypeNonterminalParser = GetNonterminal(ToUtf32("paramType"));
 5794                 paramTypeNonterminalParser->SetPre(PreparamType);
 5795                 paramTypeNonterminalParser->SetPost(PostparamType);
 5796             }
 5797             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5798             {
 5799                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5800                 context->context->AddFunctionType(context->typeId, context->fromreturnTypeId, context->paramTypeIds);
 5801             }
 5802             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5803             {
 5804                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5805                 context->paramTypeIds.Add(context->fromparamType);
 5806             }
 5807             public void PrereturnTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5808             {
 5809                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5810                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5811             }
 5812             public void PostreturnTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5813             {
 5814                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5815                 if (matched)
 5816                 {
 5817                     UniquePtr<Object> fromreturnTypeId_value = stack.Pop();
 5818                     context->fromreturnTypeId = *cast<ValueObject<string>*>(fromreturnTypeId_value.Get());
 5819                 }
 5820             }
 5821             public void PreparamType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5822             {
 5823                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5824                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5825             }
 5826             public void PostparamType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5827             {
 5828                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5829                 if (matched)
 5830                 {
 5831                     UniquePtr<Object> fromparamType_value = stack.Pop();
 5832                     context->fromparamType = *cast<ValueObject<string>*>(fromparamType_value.Get());
 5833                 }
 5834             }
 5835             public class Context : System.Text.Parsing.Context
 5836             {
 5837                 public Context() : typeId(), context(), paramTypeIds(), fromreturnTypeId(), fromparamType()
 5838                 {
 5839                 }
 5840                 public string typeId;
 5841                 public cmsx.intermediate.Context* context;
 5842                 public List<string> paramTypeIds;
 5843                 public string fromreturnTypeId;
 5844                 public string fromparamType;
 5845             }
 5846         }
 5847 
 5848         public class StrTypeIdRule : System.Text.Parsing.RuleParser
 5849         {
 5850             public StrTypeIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5851             {
 5852                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5853                 SetValueTypeName(ToUtf32("string"));
 5854             }
 5855             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5856             {
 5857                 parsingData->PushContext(Id(), new Context());
 5858                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5859                 UniquePtr<Object> context_value = stack.Pop();
 5860                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5861             }
 5862             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5863             {
 5864                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5865                 if (matched)
 5866                 {
 5867                     stack.Push(UniquePtr<Object>(new ValueObject<string>(context->value)));
 5868                 }
 5869                 parsingData->PopContext(Id());
 5870             }
 5871             public override void Link()
 5872             {
 5873                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5874                 a0ActionParser->SetAction(A0Action);
 5875                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 5876                 a1ActionParser->SetAction(A1Action);
 5877                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 5878                 a2ActionParser->SetAction(A2Action);
 5879                 NonterminalParser* uintNonterminalParser = GetNonterminal(ToUtf32("uint"));
 5880                 uintNonterminalParser->SetPost(Postuint);
 5881             }
 5882             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5883             {
 5884                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5885                 context->value = ToUtf8(ustring(matchBegin, matchEnd));
 5886             }
 5887             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5888             {
 5889                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5890                 context->value = ToUtf8(ustring(matchBegin, matchEnd));
 5891             }
 5892             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5893             {
 5894                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5895                 context->value.Append('*');
 5896                 context->context->AddPtrType(context->value, span.lineNumber);
 5897             }
 5898             public void Postuint(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5899             {
 5900                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5901                 if (matched)
 5902                 {
 5903                     UniquePtr<Object> fromuint_value = stack.Pop();
 5904                     context->fromuint = *cast<ValueObject<uint>*>(fromuint_value.Get());
 5905                 }
 5906             }
 5907             public class Context : System.Text.Parsing.Context
 5908             {
 5909                 public Context() : context(), value(), fromuint()
 5910                 {
 5911                 }
 5912                 public cmsx.intermediate.Context* context;
 5913                 public string value;
 5914                 public uint fromuint;
 5915             }
 5916         }
 5917 
 5918         public class TypeExprRule : System.Text.Parsing.RuleParser
 5919         {
 5920             public TypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5921             {
 5922                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5923                 SetValueTypeName(ToUtf32("Type*"));
 5924             }
 5925             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5926             {
 5927                 parsingData->PushContext(Id(), new Context());
 5928                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5929                 UniquePtr<Object> context_value = stack.Pop();
 5930                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5931             }
 5932             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5933             {
 5934                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5935                 if (matched)
 5936                 {
 5937                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 5938                 }
 5939                 parsingData->PopContext(Id());
 5940             }
 5941             public override void Link()
 5942             {
 5943                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 5944                 a0ActionParser->SetAction(A0Action);
 5945                 NonterminalParser* postfixTypeExprNonterminalParser = GetNonterminal(ToUtf32("PostfixTypeExpr"));
 5946                 postfixTypeExprNonterminalParser->SetPre(PrePostfixTypeExpr);
 5947                 postfixTypeExprNonterminalParser->SetPost(PostPostfixTypeExpr);
 5948             }
 5949             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 5950             {
 5951                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5952                 context->value = context->fromPostfixTypeExpr;
 5953             }
 5954             public void PrePostfixTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5955             {
 5956                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5957                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 5958             }
 5959             public void PostPostfixTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5960             {
 5961                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5962                 if (matched)
 5963                 {
 5964                     UniquePtr<Object> fromPostfixTypeExpr_value = stack.Pop();
 5965                     context->fromPostfixTypeExpr = *cast<ValueObject<Type*>*>(fromPostfixTypeExpr_value.Get());
 5966                 }
 5967             }
 5968             public class Context : System.Text.Parsing.Context
 5969             {
 5970                 public Context() : context(), value(), fromPostfixTypeExpr()
 5971                 {
 5972                 }
 5973                 public cmsx.intermediate.Context* context;
 5974                 public Type* value;
 5975                 public Type* fromPostfixTypeExpr;
 5976             }
 5977         }
 5978 
 5979         public class PostfixTypeExprRule : System.Text.Parsing.RuleParser
 5980         {
 5981             public PostfixTypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 5982             {
 5983                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 5984                 SetValueTypeName(ToUtf32("Type*"));
 5985             }
 5986             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 5987             {
 5988                 parsingData->PushContext(Id(), new Context());
 5989                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5990                 UniquePtr<Object> context_value = stack.Pop();
 5991                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 5992             }
 5993             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 5994             {
 5995                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 5996                 if (matched)
 5997                 {
 5998                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 5999                 }
 6000                 parsingData->PopContext(Id());
 6001             }
 6002             public override void Link()
 6003             {
 6004                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6005                 a0ActionParser->SetAction(A0Action);
 6006                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 6007                 a1ActionParser->SetAction(A1Action);
 6008                 NonterminalParser* primaryTypeExprNonterminalParser = GetNonterminal(ToUtf32("PrimaryTypeExpr"));
 6009                 primaryTypeExprNonterminalParser->SetPre(PrePrimaryTypeExpr);
 6010                 primaryTypeExprNonterminalParser->SetPost(PostPrimaryTypeExpr);
 6011             }
 6012             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6013             {
 6014                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6015                 context->value = context->fromPrimaryTypeExpr;
 6016             }
 6017             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6018             {
 6019                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6020                 context->value = context->context->GetPtrType(context->value);
 6021             }
 6022             public void PrePrimaryTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6023             {
 6024                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6025                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6026             }
 6027             public void PostPrimaryTypeExpr(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6028             {
 6029                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6030                 if (matched)
 6031                 {
 6032                     UniquePtr<Object> fromPrimaryTypeExpr_value = stack.Pop();
 6033                     context->fromPrimaryTypeExpr = *cast<ValueObject<Type*>*>(fromPrimaryTypeExpr_value.Get());
 6034                 }
 6035             }
 6036             public class Context : System.Text.Parsing.Context
 6037             {
 6038                 public Context() : context(), value(), fromPrimaryTypeExpr()
 6039                 {
 6040                 }
 6041                 public cmsx.intermediate.Context* context;
 6042                 public Type* value;
 6043                 public Type* fromPrimaryTypeExpr;
 6044             }
 6045         }
 6046 
 6047         public class PrimaryTypeExprRule : System.Text.Parsing.RuleParser
 6048         {
 6049             public PrimaryTypeExprRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6050             {
 6051                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6052                 SetValueTypeName(ToUtf32("Type*"));
 6053             }
 6054             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6055             {
 6056                 parsingData->PushContext(Id(), new Context());
 6057                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6058                 UniquePtr<Object> context_value = stack.Pop();
 6059                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6060             }
 6061             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6062             {
 6063                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6064                 if (matched)
 6065                 {
 6066                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6067                 }
 6068                 parsingData->PopContext(Id());
 6069             }
 6070             public override void Link()
 6071             {
 6072                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6073                 a0ActionParser->SetAction(A0Action);
 6074                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 6075                 a1ActionParser->SetAction(A1Action);
 6076                 NonterminalParser* typeIdNonterminalParser = GetNonterminal(ToUtf32("TypeId"));
 6077                 typeIdNonterminalParser->SetPre(PreTypeId);
 6078                 typeIdNonterminalParser->SetPost(PostTypeId);
 6079                 NonterminalParser* primitiveTypeNonterminalParser = GetNonterminal(ToUtf32("PrimitiveType"));
 6080                 primitiveTypeNonterminalParser->SetPre(PrePrimitiveType);
 6081                 primitiveTypeNonterminalParser->SetPost(PostPrimitiveType);
 6082             }
 6083             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6084             {
 6085                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6086                 context->value = context->fromTypeId;
 6087             }
 6088             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6089             {
 6090                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6091                 context->value = context->fromPrimitiveType;
 6092             }
 6093             public void PreTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6094             {
 6095                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6096                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6097             }
 6098             public void PostTypeId(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6099             {
 6100                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6101                 if (matched)
 6102                 {
 6103                     UniquePtr<Object> fromTypeId_value = stack.Pop();
 6104                     context->fromTypeId = *cast<ValueObject<Type*>*>(fromTypeId_value.Get());
 6105                 }
 6106             }
 6107             public void PrePrimitiveType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6108             {
 6109                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6110                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6111             }
 6112             public void PostPrimitiveType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6113             {
 6114                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6115                 if (matched)
 6116                 {
 6117                     UniquePtr<Object> fromPrimitiveType_value = stack.Pop();
 6118                     context->fromPrimitiveType = *cast<ValueObject<Type*>*>(fromPrimitiveType_value.Get());
 6119                 }
 6120             }
 6121             public class Context : System.Text.Parsing.Context
 6122             {
 6123                 public Context() : context(), value(), fromTypeId(), fromPrimitiveType()
 6124                 {
 6125                 }
 6126                 public cmsx.intermediate.Context* context;
 6127                 public Type* value;
 6128                 public Type* fromTypeId;
 6129                 public Type* fromPrimitiveType;
 6130             }
 6131         }
 6132 
 6133         public class TypeIdRule : System.Text.Parsing.RuleParser
 6134         {
 6135             public TypeIdRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6136             {
 6137                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6138                 SetValueTypeName(ToUtf32("Type*"));
 6139             }
 6140             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6141             {
 6142                 parsingData->PushContext(Id(), new Context());
 6143                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6144                 UniquePtr<Object> context_value = stack.Pop();
 6145                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6146             }
 6147             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6148             {
 6149                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6150                 if (matched)
 6151                 {
 6152                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6153                 }
 6154                 parsingData->PopContext(Id());
 6155             }
 6156             public override void Link()
 6157             {
 6158                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6159                 a0ActionParser->SetAction(A0Action);
 6160                 NonterminalParser* uintNonterminalParser = GetNonterminal(ToUtf32("uint"));
 6161                 uintNonterminalParser->SetPost(Postuint);
 6162             }
 6163             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6164             {
 6165                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6166                 context->value = context->context->GetTypeById(span.lineNumber, ToUtf8(ustring(matchBegin, matchEnd)));
 6167             }
 6168             public void Postuint(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6169             {
 6170                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6171                 if (matched)
 6172                 {
 6173                     UniquePtr<Object> fromuint_value = stack.Pop();
 6174                     context->fromuint = *cast<ValueObject<uint>*>(fromuint_value.Get());
 6175                 }
 6176             }
 6177             public class Context : System.Text.Parsing.Context
 6178             {
 6179                 public Context() : context(), value(), fromuint()
 6180                 {
 6181                 }
 6182                 public cmsx.intermediate.Context* context;
 6183                 public Type* value;
 6184                 public uint fromuint;
 6185             }
 6186         }
 6187 
 6188         public class PrimitiveTypeRule : System.Text.Parsing.RuleParser
 6189         {
 6190             public PrimitiveTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6191             {
 6192                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6193                 SetValueTypeName(ToUtf32("Type*"));
 6194             }
 6195             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6196             {
 6197                 parsingData->PushContext(Id(), new Context());
 6198                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6199                 UniquePtr<Object> context_value = stack.Pop();
 6200                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6201             }
 6202             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6203             {
 6204                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6205                 if (matched)
 6206                 {
 6207                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6208                 }
 6209                 parsingData->PopContext(Id());
 6210             }
 6211             public override void Link()
 6212             {
 6213                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6214                 a0ActionParser->SetAction(A0Action);
 6215                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 6216                 a1ActionParser->SetAction(A1Action);
 6217                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 6218                 a2ActionParser->SetAction(A2Action);
 6219                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 6220                 a3ActionParser->SetAction(A3Action);
 6221                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 6222                 a4ActionParser->SetAction(A4Action);
 6223                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 6224                 a5ActionParser->SetAction(A5Action);
 6225                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 6226                 a6ActionParser->SetAction(A6Action);
 6227                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 6228                 a7ActionParser->SetAction(A7Action);
 6229                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 6230                 a8ActionParser->SetAction(A8Action);
 6231                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 6232                 a9ActionParser->SetAction(A9Action);
 6233                 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
 6234                 a10ActionParser->SetAction(A10Action);
 6235                 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
 6236                 a11ActionParser->SetAction(A11Action);
 6237                 NonterminalParser* voidTypeNonterminalParser = GetNonterminal(ToUtf32("VoidType"));
 6238                 voidTypeNonterminalParser->SetPre(PreVoidType);
 6239                 voidTypeNonterminalParser->SetPost(PostVoidType);
 6240                 NonterminalParser* boolTypeNonterminalParser = GetNonterminal(ToUtf32("BoolType"));
 6241                 boolTypeNonterminalParser->SetPre(PreBoolType);
 6242                 boolTypeNonterminalParser->SetPost(PostBoolType);
 6243                 NonterminalParser* sByteTypeNonterminalParser = GetNonterminal(ToUtf32("SByteType"));
 6244                 sByteTypeNonterminalParser->SetPre(PreSByteType);
 6245                 sByteTypeNonterminalParser->SetPost(PostSByteType);
 6246                 NonterminalParser* byteTypeNonterminalParser = GetNonterminal(ToUtf32("ByteType"));
 6247                 byteTypeNonterminalParser->SetPre(PreByteType);
 6248                 byteTypeNonterminalParser->SetPost(PostByteType);
 6249                 NonterminalParser* shortTypeNonterminalParser = GetNonterminal(ToUtf32("ShortType"));
 6250                 shortTypeNonterminalParser->SetPre(PreShortType);
 6251                 shortTypeNonterminalParser->SetPost(PostShortType);
 6252                 NonterminalParser* uShortTypeNonterminalParser = GetNonterminal(ToUtf32("UShortType"));
 6253                 uShortTypeNonterminalParser->SetPre(PreUShortType);
 6254                 uShortTypeNonterminalParser->SetPost(PostUShortType);
 6255                 NonterminalParser* intTypeNonterminalParser = GetNonterminal(ToUtf32("IntType"));
 6256                 intTypeNonterminalParser->SetPre(PreIntType);
 6257                 intTypeNonterminalParser->SetPost(PostIntType);
 6258                 NonterminalParser* uIntTypeNonterminalParser = GetNonterminal(ToUtf32("UIntType"));
 6259                 uIntTypeNonterminalParser->SetPre(PreUIntType);
 6260                 uIntTypeNonterminalParser->SetPost(PostUIntType);
 6261                 NonterminalParser* longTypeNonterminalParser = GetNonterminal(ToUtf32("LongType"));
 6262                 longTypeNonterminalParser->SetPre(PreLongType);
 6263                 longTypeNonterminalParser->SetPost(PostLongType);
 6264                 NonterminalParser* uLongTypeNonterminalParser = GetNonterminal(ToUtf32("ULongType"));
 6265                 uLongTypeNonterminalParser->SetPre(PreULongType);
 6266                 uLongTypeNonterminalParser->SetPost(PostULongType);
 6267                 NonterminalParser* floatTypeNonterminalParser = GetNonterminal(ToUtf32("FloatType"));
 6268                 floatTypeNonterminalParser->SetPre(PreFloatType);
 6269                 floatTypeNonterminalParser->SetPost(PostFloatType);
 6270                 NonterminalParser* doubleTypeNonterminalParser = GetNonterminal(ToUtf32("DoubleType"));
 6271                 doubleTypeNonterminalParser->SetPre(PreDoubleType);
 6272                 doubleTypeNonterminalParser->SetPost(PostDoubleType);
 6273             }
 6274             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6275             {
 6276                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6277                 context->value = context->fromVoidType;
 6278             }
 6279             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6280             {
 6281                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6282                 context->value = context->fromBoolType;
 6283             }
 6284             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6285             {
 6286                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6287                 context->value = context->fromSByteType;
 6288             }
 6289             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6290             {
 6291                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6292                 context->value = context->fromByteType;
 6293             }
 6294             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6295             {
 6296                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6297                 context->value = context->fromShortType;
 6298             }
 6299             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6300             {
 6301                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6302                 context->value = context->fromUShortType;
 6303             }
 6304             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6305             {
 6306                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6307                 context->value = context->fromIntType;
 6308             }
 6309             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6310             {
 6311                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6312                 context->value = context->fromUIntType;
 6313             }
 6314             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6315             {
 6316                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6317                 context->value = context->fromLongType;
 6318             }
 6319             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6320             {
 6321                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6322                 context->value = context->fromULongType;
 6323             }
 6324             public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6325             {
 6326                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6327                 context->value = context->fromFloatType;
 6328             }
 6329             public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6330             {
 6331                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6332                 context->value = context->fromDoubleType;
 6333             }
 6334             public void PreVoidType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6335             {
 6336                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6337                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6338             }
 6339             public void PostVoidType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6340             {
 6341                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6342                 if (matched)
 6343                 {
 6344                     UniquePtr<Object> fromVoidType_value = stack.Pop();
 6345                     context->fromVoidType = *cast<ValueObject<Type*>*>(fromVoidType_value.Get());
 6346                 }
 6347             }
 6348             public void PreBoolType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6349             {
 6350                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6351                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6352             }
 6353             public void PostBoolType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6354             {
 6355                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6356                 if (matched)
 6357                 {
 6358                     UniquePtr<Object> fromBoolType_value = stack.Pop();
 6359                     context->fromBoolType = *cast<ValueObject<Type*>*>(fromBoolType_value.Get());
 6360                 }
 6361             }
 6362             public void PreSByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6363             {
 6364                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6365                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6366             }
 6367             public void PostSByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6368             {
 6369                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6370                 if (matched)
 6371                 {
 6372                     UniquePtr<Object> fromSByteType_value = stack.Pop();
 6373                     context->fromSByteType = *cast<ValueObject<Type*>*>(fromSByteType_value.Get());
 6374                 }
 6375             }
 6376             public void PreByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6377             {
 6378                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6379                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6380             }
 6381             public void PostByteType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6382             {
 6383                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6384                 if (matched)
 6385                 {
 6386                     UniquePtr<Object> fromByteType_value = stack.Pop();
 6387                     context->fromByteType = *cast<ValueObject<Type*>*>(fromByteType_value.Get());
 6388                 }
 6389             }
 6390             public void PreShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6391             {
 6392                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6393                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6394             }
 6395             public void PostShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6396             {
 6397                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6398                 if (matched)
 6399                 {
 6400                     UniquePtr<Object> fromShortType_value = stack.Pop();
 6401                     context->fromShortType = *cast<ValueObject<Type*>*>(fromShortType_value.Get());
 6402                 }
 6403             }
 6404             public void PreUShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6405             {
 6406                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6407                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6408             }
 6409             public void PostUShortType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6410             {
 6411                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6412                 if (matched)
 6413                 {
 6414                     UniquePtr<Object> fromUShortType_value = stack.Pop();
 6415                     context->fromUShortType = *cast<ValueObject<Type*>*>(fromUShortType_value.Get());
 6416                 }
 6417             }
 6418             public void PreIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6419             {
 6420                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6421                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6422             }
 6423             public void PostIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6424             {
 6425                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6426                 if (matched)
 6427                 {
 6428                     UniquePtr<Object> fromIntType_value = stack.Pop();
 6429                     context->fromIntType = *cast<ValueObject<Type*>*>(fromIntType_value.Get());
 6430                 }
 6431             }
 6432             public void PreUIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6433             {
 6434                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6435                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6436             }
 6437             public void PostUIntType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6438             {
 6439                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6440                 if (matched)
 6441                 {
 6442                     UniquePtr<Object> fromUIntType_value = stack.Pop();
 6443                     context->fromUIntType = *cast<ValueObject<Type*>*>(fromUIntType_value.Get());
 6444                 }
 6445             }
 6446             public void PreLongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6447             {
 6448                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6449                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6450             }
 6451             public void PostLongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6452             {
 6453                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6454                 if (matched)
 6455                 {
 6456                     UniquePtr<Object> fromLongType_value = stack.Pop();
 6457                     context->fromLongType = *cast<ValueObject<Type*>*>(fromLongType_value.Get());
 6458                 }
 6459             }
 6460             public void PreULongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6461             {
 6462                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6463                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6464             }
 6465             public void PostULongType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6466             {
 6467                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6468                 if (matched)
 6469                 {
 6470                     UniquePtr<Object> fromULongType_value = stack.Pop();
 6471                     context->fromULongType = *cast<ValueObject<Type*>*>(fromULongType_value.Get());
 6472                 }
 6473             }
 6474             public void PreFloatType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6475             {
 6476                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6477                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6478             }
 6479             public void PostFloatType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6480             {
 6481                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6482                 if (matched)
 6483                 {
 6484                     UniquePtr<Object> fromFloatType_value = stack.Pop();
 6485                     context->fromFloatType = *cast<ValueObject<Type*>*>(fromFloatType_value.Get());
 6486                 }
 6487             }
 6488             public void PreDoubleType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6489             {
 6490                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6491                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 6492             }
 6493             public void PostDoubleType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6494             {
 6495                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6496                 if (matched)
 6497                 {
 6498                     UniquePtr<Object> fromDoubleType_value = stack.Pop();
 6499                     context->fromDoubleType = *cast<ValueObject<Type*>*>(fromDoubleType_value.Get());
 6500                 }
 6501             }
 6502             public class Context : System.Text.Parsing.Context
 6503             {
 6504                 public Context() : context(), value(), fromVoidType(), fromBoolType(), fromSByteType(), fromByteType(), fromShortType(), fromUShortType(), fromIntType(), fromUIntType(), fromLongType(), fromULongType(), fromFloatType(), fromDoubleType()
 6505                 {
 6506                 }
 6507                 public cmsx.intermediate.Context* context;
 6508                 public Type* value;
 6509                 public Type* fromVoidType;
 6510                 public Type* fromBoolType;
 6511                 public Type* fromSByteType;
 6512                 public Type* fromByteType;
 6513                 public Type* fromShortType;
 6514                 public Type* fromUShortType;
 6515                 public Type* fromIntType;
 6516                 public Type* fromUIntType;
 6517                 public Type* fromLongType;
 6518                 public Type* fromULongType;
 6519                 public Type* fromFloatType;
 6520                 public Type* fromDoubleType;
 6521             }
 6522         }
 6523 
 6524         public class VoidTypeRule : System.Text.Parsing.RuleParser
 6525         {
 6526             public VoidTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6527             {
 6528                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6529                 SetValueTypeName(ToUtf32("Type*"));
 6530             }
 6531             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6532             {
 6533                 parsingData->PushContext(Id(), new Context());
 6534                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6535                 UniquePtr<Object> context_value = stack.Pop();
 6536                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6537             }
 6538             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6539             {
 6540                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6541                 if (matched)
 6542                 {
 6543                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6544                 }
 6545                 parsingData->PopContext(Id());
 6546             }
 6547             public override void Link()
 6548             {
 6549                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6550                 a0ActionParser->SetAction(A0Action);
 6551             }
 6552             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6553             {
 6554                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6555                 context->value = context->context->GetVoidType();
 6556             }
 6557             public class Context : System.Text.Parsing.Context
 6558             {
 6559                 public Context() : context(), value()
 6560                 {
 6561                 }
 6562                 public cmsx.intermediate.Context* context;
 6563                 public Type* value;
 6564             }
 6565         }
 6566 
 6567         public class BoolTypeRule : System.Text.Parsing.RuleParser
 6568         {
 6569             public BoolTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6570             {
 6571                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6572                 SetValueTypeName(ToUtf32("Type*"));
 6573             }
 6574             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6575             {
 6576                 parsingData->PushContext(Id(), new Context());
 6577                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6578                 UniquePtr<Object> context_value = stack.Pop();
 6579                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6580             }
 6581             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6582             {
 6583                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6584                 if (matched)
 6585                 {
 6586                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6587                 }
 6588                 parsingData->PopContext(Id());
 6589             }
 6590             public override void Link()
 6591             {
 6592                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6593                 a0ActionParser->SetAction(A0Action);
 6594             }
 6595             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6596             {
 6597                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6598                 context->value = context->context->GetBoolType();
 6599             }
 6600             public class Context : System.Text.Parsing.Context
 6601             {
 6602                 public Context() : context(), value()
 6603                 {
 6604                 }
 6605                 public cmsx.intermediate.Context* context;
 6606                 public Type* value;
 6607             }
 6608         }
 6609 
 6610         public class SByteTypeRule : System.Text.Parsing.RuleParser
 6611         {
 6612             public SByteTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6613             {
 6614                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6615                 SetValueTypeName(ToUtf32("Type*"));
 6616             }
 6617             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6618             {
 6619                 parsingData->PushContext(Id(), new Context());
 6620                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6621                 UniquePtr<Object> context_value = stack.Pop();
 6622                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6623             }
 6624             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6625             {
 6626                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6627                 if (matched)
 6628                 {
 6629                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6630                 }
 6631                 parsingData->PopContext(Id());
 6632             }
 6633             public override void Link()
 6634             {
 6635                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6636                 a0ActionParser->SetAction(A0Action);
 6637             }
 6638             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6639             {
 6640                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6641                 context->value = context->context->GetSByteType();
 6642             }
 6643             public class Context : System.Text.Parsing.Context
 6644             {
 6645                 public Context() : context(), value()
 6646                 {
 6647                 }
 6648                 public cmsx.intermediate.Context* context;
 6649                 public Type* value;
 6650             }
 6651         }
 6652 
 6653         public class ByteTypeRule : System.Text.Parsing.RuleParser
 6654         {
 6655             public ByteTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6656             {
 6657                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6658                 SetValueTypeName(ToUtf32("Type*"));
 6659             }
 6660             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6661             {
 6662                 parsingData->PushContext(Id(), new Context());
 6663                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6664                 UniquePtr<Object> context_value = stack.Pop();
 6665                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6666             }
 6667             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6668             {
 6669                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6670                 if (matched)
 6671                 {
 6672                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6673                 }
 6674                 parsingData->PopContext(Id());
 6675             }
 6676             public override void Link()
 6677             {
 6678                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6679                 a0ActionParser->SetAction(A0Action);
 6680             }
 6681             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6682             {
 6683                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6684                 context->value = context->context->GetByteType();
 6685             }
 6686             public class Context : System.Text.Parsing.Context
 6687             {
 6688                 public Context() : context(), value()
 6689                 {
 6690                 }
 6691                 public cmsx.intermediate.Context* context;
 6692                 public Type* value;
 6693             }
 6694         }
 6695 
 6696         public class ShortTypeRule : System.Text.Parsing.RuleParser
 6697         {
 6698             public ShortTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6699             {
 6700                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6701                 SetValueTypeName(ToUtf32("Type*"));
 6702             }
 6703             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6704             {
 6705                 parsingData->PushContext(Id(), new Context());
 6706                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6707                 UniquePtr<Object> context_value = stack.Pop();
 6708                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6709             }
 6710             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6711             {
 6712                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6713                 if (matched)
 6714                 {
 6715                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6716                 }
 6717                 parsingData->PopContext(Id());
 6718             }
 6719             public override void Link()
 6720             {
 6721                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6722                 a0ActionParser->SetAction(A0Action);
 6723             }
 6724             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6725             {
 6726                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6727                 context->value = context->context->GetShortType();
 6728             }
 6729             public class Context : System.Text.Parsing.Context
 6730             {
 6731                 public Context() : context(), value()
 6732                 {
 6733                 }
 6734                 public cmsx.intermediate.Context* context;
 6735                 public Type* value;
 6736             }
 6737         }
 6738 
 6739         public class UShortTypeRule : System.Text.Parsing.RuleParser
 6740         {
 6741             public UShortTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6742             {
 6743                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6744                 SetValueTypeName(ToUtf32("Type*"));
 6745             }
 6746             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6747             {
 6748                 parsingData->PushContext(Id(), new Context());
 6749                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6750                 UniquePtr<Object> context_value = stack.Pop();
 6751                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6752             }
 6753             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6754             {
 6755                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6756                 if (matched)
 6757                 {
 6758                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6759                 }
 6760                 parsingData->PopContext(Id());
 6761             }
 6762             public override void Link()
 6763             {
 6764                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6765                 a0ActionParser->SetAction(A0Action);
 6766             }
 6767             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6768             {
 6769                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6770                 context->value = context->context->GetUShortType();
 6771             }
 6772             public class Context : System.Text.Parsing.Context
 6773             {
 6774                 public Context() : context(), value()
 6775                 {
 6776                 }
 6777                 public cmsx.intermediate.Context* context;
 6778                 public Type* value;
 6779             }
 6780         }
 6781 
 6782         public class IntTypeRule : System.Text.Parsing.RuleParser
 6783         {
 6784             public IntTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6785             {
 6786                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6787                 SetValueTypeName(ToUtf32("Type*"));
 6788             }
 6789             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6790             {
 6791                 parsingData->PushContext(Id(), new Context());
 6792                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6793                 UniquePtr<Object> context_value = stack.Pop();
 6794                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6795             }
 6796             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6797             {
 6798                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6799                 if (matched)
 6800                 {
 6801                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6802                 }
 6803                 parsingData->PopContext(Id());
 6804             }
 6805             public override void Link()
 6806             {
 6807                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6808                 a0ActionParser->SetAction(A0Action);
 6809             }
 6810             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6811             {
 6812                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6813                 context->value = context->context->GetIntType();
 6814             }
 6815             public class Context : System.Text.Parsing.Context
 6816             {
 6817                 public Context() : context(), value()
 6818                 {
 6819                 }
 6820                 public cmsx.intermediate.Context* context;
 6821                 public Type* value;
 6822             }
 6823         }
 6824 
 6825         public class UIntTypeRule : System.Text.Parsing.RuleParser
 6826         {
 6827             public UIntTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6828             {
 6829                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6830                 SetValueTypeName(ToUtf32("Type*"));
 6831             }
 6832             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6833             {
 6834                 parsingData->PushContext(Id(), new Context());
 6835                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6836                 UniquePtr<Object> context_value = stack.Pop();
 6837                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6838             }
 6839             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6840             {
 6841                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6842                 if (matched)
 6843                 {
 6844                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6845                 }
 6846                 parsingData->PopContext(Id());
 6847             }
 6848             public override void Link()
 6849             {
 6850                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6851                 a0ActionParser->SetAction(A0Action);
 6852             }
 6853             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6854             {
 6855                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6856                 context->value = context->context->GetUIntType();
 6857             }
 6858             public class Context : System.Text.Parsing.Context
 6859             {
 6860                 public Context() : context(), value()
 6861                 {
 6862                 }
 6863                 public cmsx.intermediate.Context* context;
 6864                 public Type* value;
 6865             }
 6866         }
 6867 
 6868         public class LongTypeRule : System.Text.Parsing.RuleParser
 6869         {
 6870             public LongTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6871             {
 6872                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6873                 SetValueTypeName(ToUtf32("Type*"));
 6874             }
 6875             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6876             {
 6877                 parsingData->PushContext(Id(), new Context());
 6878                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6879                 UniquePtr<Object> context_value = stack.Pop();
 6880                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6881             }
 6882             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6883             {
 6884                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6885                 if (matched)
 6886                 {
 6887                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6888                 }
 6889                 parsingData->PopContext(Id());
 6890             }
 6891             public override void Link()
 6892             {
 6893                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6894                 a0ActionParser->SetAction(A0Action);
 6895             }
 6896             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6897             {
 6898                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6899                 context->value = context->context->GetLongType();
 6900             }
 6901             public class Context : System.Text.Parsing.Context
 6902             {
 6903                 public Context() : context(), value()
 6904                 {
 6905                 }
 6906                 public cmsx.intermediate.Context* context;
 6907                 public Type* value;
 6908             }
 6909         }
 6910 
 6911         public class ULongTypeRule : System.Text.Parsing.RuleParser
 6912         {
 6913             public ULongTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6914             {
 6915                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6916                 SetValueTypeName(ToUtf32("Type*"));
 6917             }
 6918             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6919             {
 6920                 parsingData->PushContext(Id(), new Context());
 6921                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6922                 UniquePtr<Object> context_value = stack.Pop();
 6923                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6924             }
 6925             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6926             {
 6927                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6928                 if (matched)
 6929                 {
 6930                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6931                 }
 6932                 parsingData->PopContext(Id());
 6933             }
 6934             public override void Link()
 6935             {
 6936                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6937                 a0ActionParser->SetAction(A0Action);
 6938             }
 6939             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6940             {
 6941                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6942                 context->value = context->context->GetULongType();
 6943             }
 6944             public class Context : System.Text.Parsing.Context
 6945             {
 6946                 public Context() : context(), value()
 6947                 {
 6948                 }
 6949                 public cmsx.intermediate.Context* context;
 6950                 public Type* value;
 6951             }
 6952         }
 6953 
 6954         public class FloatTypeRule : System.Text.Parsing.RuleParser
 6955         {
 6956             public FloatTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 6957             {
 6958                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 6959                 SetValueTypeName(ToUtf32("Type*"));
 6960             }
 6961             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 6962             {
 6963                 parsingData->PushContext(Id(), new Context());
 6964                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6965                 UniquePtr<Object> context_value = stack.Pop();
 6966                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 6967             }
 6968             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 6969             {
 6970                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6971                 if (matched)
 6972                 {
 6973                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 6974                 }
 6975                 parsingData->PopContext(Id());
 6976             }
 6977             public override void Link()
 6978             {
 6979                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 6980                 a0ActionParser->SetAction(A0Action);
 6981             }
 6982             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 6983             {
 6984                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 6985                 context->value = context->context->GetFloatType();
 6986             }
 6987             public class Context : System.Text.Parsing.Context
 6988             {
 6989                 public Context() : context(), value()
 6990                 {
 6991                 }
 6992                 public cmsx.intermediate.Context* context;
 6993                 public Type* value;
 6994             }
 6995         }
 6996 
 6997         public class DoubleTypeRule : System.Text.Parsing.RuleParser
 6998         {
 6999             public DoubleTypeRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7000             {
 7001                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7002                 SetValueTypeName(ToUtf32("Type*"));
 7003             }
 7004             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7005             {
 7006                 parsingData->PushContext(Id(), new Context());
 7007                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7008                 UniquePtr<Object> context_value = stack.Pop();
 7009                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7010             }
 7011             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7012             {
 7013                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7014                 if (matched)
 7015                 {
 7016                     stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->value)));
 7017                 }
 7018                 parsingData->PopContext(Id());
 7019             }
 7020             public override void Link()
 7021             {
 7022                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7023                 a0ActionParser->SetAction(A0Action);
 7024             }
 7025             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7026             {
 7027                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7028                 context->value = context->context->GetDoubleType();
 7029             }
 7030             public class Context : System.Text.Parsing.Context
 7031             {
 7032                 public Context() : context(), value()
 7033                 {
 7034                 }
 7035                 public cmsx.intermediate.Context* context;
 7036                 public Type* value;
 7037             }
 7038         }
 7039 
 7040         public class DataDefinitionRule : System.Text.Parsing.RuleParser
 7041         {
 7042             public DataDefinitionRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7043             {
 7044                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7045                 AddLocalVariable(AttrOrVar(ToUtf32("bool"), ToUtf32("once")));
 7046             }
 7047             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7048             {
 7049                 parsingData->PushContext(Id(), new Context());
 7050                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7051                 UniquePtr<Object> context_value = stack.Pop();
 7052                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7053             }
 7054             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7055             {
 7056                 parsingData->PopContext(Id());
 7057             }
 7058             public override void Link()
 7059             {
 7060                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7061                 a0ActionParser->SetAction(A0Action);
 7062                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 7063                 a1ActionParser->SetAction(A1Action);
 7064                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 7065                 a2ActionParser->SetAction(A2Action);
 7066                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7067                 typeNonterminalParser->SetPre(Pretype);
 7068                 typeNonterminalParser->SetPost(Posttype);
 7069                 NonterminalParser* nameNonterminalParser = GetNonterminal(ToUtf32("name"));
 7070                 nameNonterminalParser->SetPost(Postname);
 7071                 NonterminalParser* constantNonterminalParser = GetNonterminal(ToUtf32("Constant"));
 7072                 constantNonterminalParser->SetPre(PreConstant);
 7073                 constantNonterminalParser->SetPost(PostConstant);
 7074             }
 7075             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7076             {
 7077                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7078                 context->once = true;
 7079             }
 7080             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7081             {
 7082                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7083                 context->context->AddGlobalVariable(context->fromtype, ToUtf8(context->fromname), cast<ConstantValue*>(null), span.lineNumber, context->once);
 7084             }
 7085             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7086             {
 7087                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7088                 context->context->AddGlobalVariable(context->fromtype, ToUtf8(context->fromname), context->fromConstant, span.lineNumber, context->once);
 7089             }
 7090             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7091             {
 7092                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7093                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7094             }
 7095             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7096             {
 7097                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7098                 if (matched)
 7099                 {
 7100                     UniquePtr<Object> fromtype_value = stack.Pop();
 7101                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7102                 }
 7103             }
 7104             public void Postname(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7105             {
 7106                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7107                 if (matched)
 7108                 {
 7109                     UniquePtr<Object> fromname_value = stack.Pop();
 7110                     context->fromname = *cast<ValueObject<ustring>*>(fromname_value.Get());
 7111                 }
 7112             }
 7113             public void PreConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7114             {
 7115                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7116                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7117             }
 7118             public void PostConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7119             {
 7120                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7121                 if (matched)
 7122                 {
 7123                     UniquePtr<Object> fromConstant_value = stack.Pop();
 7124                     context->fromConstant = *cast<ValueObject<ConstantValue*>*>(fromConstant_value.Get());
 7125                 }
 7126             }
 7127             public class Context : System.Text.Parsing.Context
 7128             {
 7129                 public Context() : context(), once(), fromtype(), fromname(), fromConstant()
 7130                 {
 7131                 }
 7132                 public cmsx.intermediate.Context* context;
 7133                 public bool once;
 7134                 public Type* fromtype;
 7135                 public ustring fromname;
 7136                 public ConstantValue* fromConstant;
 7137             }
 7138         }
 7139 
 7140         public class ConstantRule : System.Text.Parsing.RuleParser
 7141         {
 7142             public ConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7143             {
 7144                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7145                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7146             }
 7147             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7148             {
 7149                 parsingData->PushContext(Id(), new Context());
 7150                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7151                 UniquePtr<Object> context_value = stack.Pop();
 7152                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7153             }
 7154             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7155             {
 7156                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7157                 if (matched)
 7158                 {
 7159                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7160                 }
 7161                 parsingData->PopContext(Id());
 7162             }
 7163             public override void Link()
 7164             {
 7165                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7166                 a0ActionParser->SetAction(A0Action);
 7167                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 7168                 a1ActionParser->SetAction(A1Action);
 7169                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 7170                 a2ActionParser->SetAction(A2Action);
 7171                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 7172                 a3ActionParser->SetAction(A3Action);
 7173                 ActionParser* a4ActionParser = GetAction(ToUtf32("A4"));
 7174                 a4ActionParser->SetAction(A4Action);
 7175                 ActionParser* a5ActionParser = GetAction(ToUtf32("A5"));
 7176                 a5ActionParser->SetAction(A5Action);
 7177                 ActionParser* a6ActionParser = GetAction(ToUtf32("A6"));
 7178                 a6ActionParser->SetAction(A6Action);
 7179                 ActionParser* a7ActionParser = GetAction(ToUtf32("A7"));
 7180                 a7ActionParser->SetAction(A7Action);
 7181                 ActionParser* a8ActionParser = GetAction(ToUtf32("A8"));
 7182                 a8ActionParser->SetAction(A8Action);
 7183                 ActionParser* a9ActionParser = GetAction(ToUtf32("A9"));
 7184                 a9ActionParser->SetAction(A9Action);
 7185                 ActionParser* a10ActionParser = GetAction(ToUtf32("A10"));
 7186                 a10ActionParser->SetAction(A10Action);
 7187                 ActionParser* a11ActionParser = GetAction(ToUtf32("A11"));
 7188                 a11ActionParser->SetAction(A11Action);
 7189                 ActionParser* a12ActionParser = GetAction(ToUtf32("A12"));
 7190                 a12ActionParser->SetAction(A12Action);
 7191                 ActionParser* a13ActionParser = GetAction(ToUtf32("A13"));
 7192                 a13ActionParser->SetAction(A13Action);
 7193                 ActionParser* a14ActionParser = GetAction(ToUtf32("A14"));
 7194                 a14ActionParser->SetAction(A14Action);
 7195                 ActionParser* a15ActionParser = GetAction(ToUtf32("A15"));
 7196                 a15ActionParser->SetAction(A15Action);
 7197                 ActionParser* a16ActionParser = GetAction(ToUtf32("A16"));
 7198                 a16ActionParser->SetAction(A16Action);
 7199                 ActionParser* a17ActionParser = GetAction(ToUtf32("A17"));
 7200                 a17ActionParser->SetAction(A17Action);
 7201                 ActionParser* a18ActionParser = GetAction(ToUtf32("A18"));
 7202                 a18ActionParser->SetAction(A18Action);
 7203                 NonterminalParser* conversionConstantNonterminalParser = GetNonterminal(ToUtf32("ConversionConstant"));
 7204                 conversionConstantNonterminalParser->SetPre(PreConversionConstant);
 7205                 conversionConstantNonterminalParser->SetPost(PostConversionConstant);
 7206                 NonterminalParser* clsIdConstantNonterminalParser = GetNonterminal(ToUtf32("ClsIdConstant"));
 7207                 clsIdConstantNonterminalParser->SetPre(PreClsIdConstant);
 7208                 clsIdConstantNonterminalParser->SetPost(PostClsIdConstant);
 7209                 NonterminalParser* ptrConstantNonterminalParser = GetNonterminal(ToUtf32("PtrConstant"));
 7210                 ptrConstantNonterminalParser->SetPre(PrePtrConstant);
 7211                 ptrConstantNonterminalParser->SetPost(PostPtrConstant);
 7212                 NonterminalParser* symbolConstantNonterminalParser = GetNonterminal(ToUtf32("SymbolConstant"));
 7213                 symbolConstantNonterminalParser->SetPre(PreSymbolConstant);
 7214                 symbolConstantNonterminalParser->SetPost(PostSymbolConstant);
 7215                 NonterminalParser* boolConstantNonterminalParser = GetNonterminal(ToUtf32("BoolConstant"));
 7216                 boolConstantNonterminalParser->SetPre(PreBoolConstant);
 7217                 boolConstantNonterminalParser->SetPost(PostBoolConstant);
 7218                 NonterminalParser* sByteConstantNonterminalParser = GetNonterminal(ToUtf32("SByteConstant"));
 7219                 sByteConstantNonterminalParser->SetPre(PreSByteConstant);
 7220                 sByteConstantNonterminalParser->SetPost(PostSByteConstant);
 7221                 NonterminalParser* byteConstantNonterminalParser = GetNonterminal(ToUtf32("ByteConstant"));
 7222                 byteConstantNonterminalParser->SetPre(PreByteConstant);
 7223                 byteConstantNonterminalParser->SetPost(PostByteConstant);
 7224                 NonterminalParser* shortConstantNonterminalParser = GetNonterminal(ToUtf32("ShortConstant"));
 7225                 shortConstantNonterminalParser->SetPre(PreShortConstant);
 7226                 shortConstantNonterminalParser->SetPost(PostShortConstant);
 7227                 NonterminalParser* uShortConstantNonterminalParser = GetNonterminal(ToUtf32("UShortConstant"));
 7228                 uShortConstantNonterminalParser->SetPre(PreUShortConstant);
 7229                 uShortConstantNonterminalParser->SetPost(PostUShortConstant);
 7230                 NonterminalParser* intConstantNonterminalParser = GetNonterminal(ToUtf32("IntConstant"));
 7231                 intConstantNonterminalParser->SetPre(PreIntConstant);
 7232                 intConstantNonterminalParser->SetPost(PostIntConstant);
 7233                 NonterminalParser* uIntConstantNonterminalParser = GetNonterminal(ToUtf32("UIntConstant"));
 7234                 uIntConstantNonterminalParser->SetPre(PreUIntConstant);
 7235                 uIntConstantNonterminalParser->SetPost(PostUIntConstant);
 7236                 NonterminalParser* longConstantNonterminalParser = GetNonterminal(ToUtf32("LongConstant"));
 7237                 longConstantNonterminalParser->SetPre(PreLongConstant);
 7238                 longConstantNonterminalParser->SetPost(PostLongConstant);
 7239                 NonterminalParser* uLongConstantNonterminalParser = GetNonterminal(ToUtf32("ULongConstant"));
 7240                 uLongConstantNonterminalParser->SetPre(PreULongConstant);
 7241                 uLongConstantNonterminalParser->SetPost(PostULongConstant);
 7242                 NonterminalParser* floatConstantNonterminalParser = GetNonterminal(ToUtf32("FloatConstant"));
 7243                 floatConstantNonterminalParser->SetPre(PreFloatConstant);
 7244                 floatConstantNonterminalParser->SetPost(PostFloatConstant);
 7245                 NonterminalParser* doubleConstantNonterminalParser = GetNonterminal(ToUtf32("DoubleConstant"));
 7246                 doubleConstantNonterminalParser->SetPre(PreDoubleConstant);
 7247                 doubleConstantNonterminalParser->SetPost(PostDoubleConstant);
 7248                 NonterminalParser* arrayConstantNonterminalParser = GetNonterminal(ToUtf32("ArrayConstant"));
 7249                 arrayConstantNonterminalParser->SetPre(PreArrayConstant);
 7250                 arrayConstantNonterminalParser->SetPost(PostArrayConstant);
 7251                 NonterminalParser* structureConstantNonterminalParser = GetNonterminal(ToUtf32("StructureConstant"));
 7252                 structureConstantNonterminalParser->SetPre(PreStructureConstant);
 7253                 structureConstantNonterminalParser->SetPost(PostStructureConstant);
 7254                 NonterminalParser* stringConstantNonterminalParser = GetNonterminal(ToUtf32("StringConstant"));
 7255                 stringConstantNonterminalParser->SetPre(PreStringConstant);
 7256                 stringConstantNonterminalParser->SetPost(PostStringConstant);
 7257                 NonterminalParser* stringArrayConstantNonterminalParser = GetNonterminal(ToUtf32("StringArrayConstant"));
 7258                 stringArrayConstantNonterminalParser->SetPre(PreStringArrayConstant);
 7259                 stringArrayConstantNonterminalParser->SetPost(PostStringArrayConstant);
 7260             }
 7261             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7262             {
 7263                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7264                 context->value = context->fromConversionConstant;
 7265             }
 7266             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7267             {
 7268                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7269                 context->value = context->fromClsIdConstant;
 7270             }
 7271             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7272             {
 7273                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7274                 context->value = context->fromPtrConstant;
 7275             }
 7276             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7277             {
 7278                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7279                 context->value = context->fromSymbolConstant;
 7280             }
 7281             public void A4Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7282             {
 7283                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7284                 context->value = context->fromBoolConstant;
 7285             }
 7286             public void A5Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7287             {
 7288                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7289                 context->value = context->fromSByteConstant;
 7290             }
 7291             public void A6Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7292             {
 7293                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7294                 context->value = context->fromByteConstant;
 7295             }
 7296             public void A7Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7297             {
 7298                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7299                 context->value = context->fromShortConstant;
 7300             }
 7301             public void A8Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7302             {
 7303                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7304                 context->value = context->fromUShortConstant;
 7305             }
 7306             public void A9Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7307             {
 7308                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7309                 context->value = context->fromIntConstant;
 7310             }
 7311             public void A10Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7312             {
 7313                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7314                 context->value = context->fromUIntConstant;
 7315             }
 7316             public void A11Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7317             {
 7318                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7319                 context->value = context->fromLongConstant;
 7320             }
 7321             public void A12Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7322             {
 7323                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7324                 context->value = context->fromULongConstant;
 7325             }
 7326             public void A13Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7327             {
 7328                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7329                 context->value = context->fromFloatConstant;
 7330             }
 7331             public void A14Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7332             {
 7333                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7334                 context->value = context->fromDoubleConstant;
 7335             }
 7336             public void A15Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7337             {
 7338                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7339                 context->value = context->fromArrayConstant;
 7340             }
 7341             public void A16Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7342             {
 7343                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7344                 context->value = context->fromStructureConstant;
 7345             }
 7346             public void A17Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7347             {
 7348                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7349                 context->value = context->fromStringConstant;
 7350             }
 7351             public void A18Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7352             {
 7353                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7354                 context->value = context->fromStringArrayConstant;
 7355             }
 7356             public void PreConversionConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7357             {
 7358                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7359                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7360             }
 7361             public void PostConversionConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7362             {
 7363                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7364                 if (matched)
 7365                 {
 7366                     UniquePtr<Object> fromConversionConstant_value = stack.Pop();
 7367                     context->fromConversionConstant = *cast<ValueObject<ConstantValue*>*>(fromConversionConstant_value.Get());
 7368                 }
 7369             }
 7370             public void PreClsIdConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7371             {
 7372                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7373                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7374             }
 7375             public void PostClsIdConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7376             {
 7377                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7378                 if (matched)
 7379                 {
 7380                     UniquePtr<Object> fromClsIdConstant_value = stack.Pop();
 7381                     context->fromClsIdConstant = *cast<ValueObject<ConstantValue*>*>(fromClsIdConstant_value.Get());
 7382                 }
 7383             }
 7384             public void PrePtrConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7385             {
 7386                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7387                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7388             }
 7389             public void PostPtrConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7390             {
 7391                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7392                 if (matched)
 7393                 {
 7394                     UniquePtr<Object> fromPtrConstant_value = stack.Pop();
 7395                     context->fromPtrConstant = *cast<ValueObject<ConstantValue*>*>(fromPtrConstant_value.Get());
 7396                 }
 7397             }
 7398             public void PreSymbolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7399             {
 7400                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7401                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7402             }
 7403             public void PostSymbolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7404             {
 7405                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7406                 if (matched)
 7407                 {
 7408                     UniquePtr<Object> fromSymbolConstant_value = stack.Pop();
 7409                     context->fromSymbolConstant = *cast<ValueObject<ConstantValue*>*>(fromSymbolConstant_value.Get());
 7410                 }
 7411             }
 7412             public void PreBoolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7413             {
 7414                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7415                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7416             }
 7417             public void PostBoolConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7418             {
 7419                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7420                 if (matched)
 7421                 {
 7422                     UniquePtr<Object> fromBoolConstant_value = stack.Pop();
 7423                     context->fromBoolConstant = *cast<ValueObject<ConstantValue*>*>(fromBoolConstant_value.Get());
 7424                 }
 7425             }
 7426             public void PreSByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7427             {
 7428                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7429                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7430             }
 7431             public void PostSByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7432             {
 7433                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7434                 if (matched)
 7435                 {
 7436                     UniquePtr<Object> fromSByteConstant_value = stack.Pop();
 7437                     context->fromSByteConstant = *cast<ValueObject<ConstantValue*>*>(fromSByteConstant_value.Get());
 7438                 }
 7439             }
 7440             public void PreByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7441             {
 7442                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7443                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7444             }
 7445             public void PostByteConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7446             {
 7447                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7448                 if (matched)
 7449                 {
 7450                     UniquePtr<Object> fromByteConstant_value = stack.Pop();
 7451                     context->fromByteConstant = *cast<ValueObject<ConstantValue*>*>(fromByteConstant_value.Get());
 7452                 }
 7453             }
 7454             public void PreShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7455             {
 7456                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7457                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7458             }
 7459             public void PostShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7460             {
 7461                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7462                 if (matched)
 7463                 {
 7464                     UniquePtr<Object> fromShortConstant_value = stack.Pop();
 7465                     context->fromShortConstant = *cast<ValueObject<ConstantValue*>*>(fromShortConstant_value.Get());
 7466                 }
 7467             }
 7468             public void PreUShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7469             {
 7470                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7471                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7472             }
 7473             public void PostUShortConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7474             {
 7475                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7476                 if (matched)
 7477                 {
 7478                     UniquePtr<Object> fromUShortConstant_value = stack.Pop();
 7479                     context->fromUShortConstant = *cast<ValueObject<ConstantValue*>*>(fromUShortConstant_value.Get());
 7480                 }
 7481             }
 7482             public void PreIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7483             {
 7484                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7485                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7486             }
 7487             public void PostIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7488             {
 7489                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7490                 if (matched)
 7491                 {
 7492                     UniquePtr<Object> fromIntConstant_value = stack.Pop();
 7493                     context->fromIntConstant = *cast<ValueObject<ConstantValue*>*>(fromIntConstant_value.Get());
 7494                 }
 7495             }
 7496             public void PreUIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7497             {
 7498                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7499                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7500             }
 7501             public void PostUIntConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7502             {
 7503                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7504                 if (matched)
 7505                 {
 7506                     UniquePtr<Object> fromUIntConstant_value = stack.Pop();
 7507                     context->fromUIntConstant = *cast<ValueObject<ConstantValue*>*>(fromUIntConstant_value.Get());
 7508                 }
 7509             }
 7510             public void PreLongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7511             {
 7512                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7513                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7514             }
 7515             public void PostLongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7516             {
 7517                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7518                 if (matched)
 7519                 {
 7520                     UniquePtr<Object> fromLongConstant_value = stack.Pop();
 7521                     context->fromLongConstant = *cast<ValueObject<ConstantValue*>*>(fromLongConstant_value.Get());
 7522                 }
 7523             }
 7524             public void PreULongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7525             {
 7526                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7527                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7528             }
 7529             public void PostULongConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7530             {
 7531                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7532                 if (matched)
 7533                 {
 7534                     UniquePtr<Object> fromULongConstant_value = stack.Pop();
 7535                     context->fromULongConstant = *cast<ValueObject<ConstantValue*>*>(fromULongConstant_value.Get());
 7536                 }
 7537             }
 7538             public void PreFloatConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7539             {
 7540                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7541                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7542             }
 7543             public void PostFloatConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7544             {
 7545                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7546                 if (matched)
 7547                 {
 7548                     UniquePtr<Object> fromFloatConstant_value = stack.Pop();
 7549                     context->fromFloatConstant = *cast<ValueObject<ConstantValue*>*>(fromFloatConstant_value.Get());
 7550                 }
 7551             }
 7552             public void PreDoubleConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7553             {
 7554                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7555                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7556             }
 7557             public void PostDoubleConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7558             {
 7559                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7560                 if (matched)
 7561                 {
 7562                     UniquePtr<Object> fromDoubleConstant_value = stack.Pop();
 7563                     context->fromDoubleConstant = *cast<ValueObject<ConstantValue*>*>(fromDoubleConstant_value.Get());
 7564                 }
 7565             }
 7566             public void PreArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7567             {
 7568                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7569                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7570             }
 7571             public void PostArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7572             {
 7573                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7574                 if (matched)
 7575                 {
 7576                     UniquePtr<Object> fromArrayConstant_value = stack.Pop();
 7577                     context->fromArrayConstant = *cast<ValueObject<ArrayValue*>*>(fromArrayConstant_value.Get());
 7578                 }
 7579             }
 7580             public void PreStructureConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7581             {
 7582                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7583                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7584             }
 7585             public void PostStructureConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7586             {
 7587                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7588                 if (matched)
 7589                 {
 7590                     UniquePtr<Object> fromStructureConstant_value = stack.Pop();
 7591                     context->fromStructureConstant = *cast<ValueObject<StructureValue*>*>(fromStructureConstant_value.Get());
 7592                 }
 7593             }
 7594             public void PreStringConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7595             {
 7596                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7597                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7598             }
 7599             public void PostStringConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7600             {
 7601                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7602                 if (matched)
 7603                 {
 7604                     UniquePtr<Object> fromStringConstant_value = stack.Pop();
 7605                     context->fromStringConstant = *cast<ValueObject<StringValue*>*>(fromStringConstant_value.Get());
 7606                 }
 7607             }
 7608             public void PreStringArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7609             {
 7610                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7611                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7612             }
 7613             public void PostStringArrayConstant(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7614             {
 7615                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7616                 if (matched)
 7617                 {
 7618                     UniquePtr<Object> fromStringArrayConstant_value = stack.Pop();
 7619                     context->fromStringArrayConstant = *cast<ValueObject<StringArrayValue*>*>(fromStringArrayConstant_value.Get());
 7620                 }
 7621             }
 7622             public class Context : System.Text.Parsing.Context
 7623             {
 7624                 public Context() : context(), value(), fromConversionConstant(), fromClsIdConstant(), fromPtrConstant(), fromSymbolConstant(), fromBoolConstant(), fromSByteConstant(), fromByteConstant(), fromShortConstant(), fromUShortConstant(), fromIntConstant(), fromUIntConstant(), fromLongConstant(), fromULongConstant(), fromFloatConstant(), fromDoubleConstant(), fromArrayConstant(), fromStructureConstant(), fromStringConstant(), fromStringArrayConstant()
 7625                 {
 7626                 }
 7627                 public cmsx.intermediate.Context* context;
 7628                 public ConstantValue* value;
 7629                 public ConstantValue* fromConversionConstant;
 7630                 public ConstantValue* fromClsIdConstant;
 7631                 public ConstantValue* fromPtrConstant;
 7632                 public ConstantValue* fromSymbolConstant;
 7633                 public ConstantValue* fromBoolConstant;
 7634                 public ConstantValue* fromSByteConstant;
 7635                 public ConstantValue* fromByteConstant;
 7636                 public ConstantValue* fromShortConstant;
 7637                 public ConstantValue* fromUShortConstant;
 7638                 public ConstantValue* fromIntConstant;
 7639                 public ConstantValue* fromUIntConstant;
 7640                 public ConstantValue* fromLongConstant;
 7641                 public ConstantValue* fromULongConstant;
 7642                 public ConstantValue* fromFloatConstant;
 7643                 public ConstantValue* fromDoubleConstant;
 7644                 public ArrayValue* fromArrayConstant;
 7645                 public StructureValue* fromStructureConstant;
 7646                 public StringValue* fromStringConstant;
 7647                 public StringArrayValue* fromStringArrayConstant;
 7648             }
 7649         }
 7650 
 7651         public class BoolConstantRule : System.Text.Parsing.RuleParser
 7652         {
 7653             public BoolConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7654             {
 7655                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7656                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7657             }
 7658             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7659             {
 7660                 parsingData->PushContext(Id(), new Context());
 7661                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7662                 UniquePtr<Object> context_value = stack.Pop();
 7663                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7664             }
 7665             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7666             {
 7667                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7668                 if (matched)
 7669                 {
 7670                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7671                 }
 7672                 parsingData->PopContext(Id());
 7673             }
 7674             public override void Link()
 7675             {
 7676                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7677                 a0ActionParser->SetAction(A0Action);
 7678                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7679                 typeNonterminalParser->SetPre(Pretype);
 7680                 typeNonterminalParser->SetPost(Posttype);
 7681                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 7682                 valNonterminalParser->SetPost(Postval);
 7683             }
 7684             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7685             {
 7686                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7687                 context->value = cast<BoolType*>(context->fromtype)->MakeBoolValue(context->fromval);
 7688             }
 7689             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7690             {
 7691                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7692                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7693             }
 7694             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7695             {
 7696                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7697                 if (matched)
 7698                 {
 7699                     UniquePtr<Object> fromtype_value = stack.Pop();
 7700                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7701                 }
 7702             }
 7703             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7704             {
 7705                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7706                 if (matched)
 7707                 {
 7708                     UniquePtr<Object> fromval_value = stack.Pop();
 7709                     context->fromval = *cast<ValueObject<bool>*>(fromval_value.Get());
 7710                 }
 7711             }
 7712             public class Context : System.Text.Parsing.Context
 7713             {
 7714                 public Context() : context(), value(), fromtype(), fromval()
 7715                 {
 7716                 }
 7717                 public cmsx.intermediate.Context* context;
 7718                 public ConstantValue* value;
 7719                 public Type* fromtype;
 7720                 public bool fromval;
 7721             }
 7722         }
 7723 
 7724         public class BoolValueRule : System.Text.Parsing.RuleParser
 7725         {
 7726             public BoolValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7727             {
 7728                 SetValueTypeName(ToUtf32("bool"));
 7729             }
 7730             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7731             {
 7732                 parsingData->PushContext(Id(), new Context());
 7733                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7734             }
 7735             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7736             {
 7737                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7738                 if (matched)
 7739                 {
 7740                     stack.Push(UniquePtr<Object>(new ValueObject<bool>(context->value)));
 7741                 }
 7742                 parsingData->PopContext(Id());
 7743             }
 7744             public override void Link()
 7745             {
 7746                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7747                 a0ActionParser->SetAction(A0Action);
 7748                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 7749                 xNonterminalParser->SetPost(Postx);
 7750             }
 7751             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7752             {
 7753                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7754                 context->value = context->fromx;
 7755             }
 7756             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7757             {
 7758                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7759                 if (matched)
 7760                 {
 7761                     UniquePtr<Object> fromx_value = stack.Pop();
 7762                     context->fromx = *cast<ValueObject<bool>*>(fromx_value.Get());
 7763                 }
 7764             }
 7765             public class Context : System.Text.Parsing.Context
 7766             {
 7767                 public Context() : value(), fromx()
 7768                 {
 7769                 }
 7770                 public bool value;
 7771                 public bool fromx;
 7772             }
 7773         }
 7774 
 7775         public class SByteConstantRule : System.Text.Parsing.RuleParser
 7776         {
 7777             public SByteConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7778             {
 7779                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7780                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7781             }
 7782             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7783             {
 7784                 parsingData->PushContext(Id(), new Context());
 7785                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7786                 UniquePtr<Object> context_value = stack.Pop();
 7787                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7788             }
 7789             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7790             {
 7791                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7792                 if (matched)
 7793                 {
 7794                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7795                 }
 7796                 parsingData->PopContext(Id());
 7797             }
 7798             public override void Link()
 7799             {
 7800                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7801                 a0ActionParser->SetAction(A0Action);
 7802                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7803                 typeNonterminalParser->SetPre(Pretype);
 7804                 typeNonterminalParser->SetPost(Posttype);
 7805                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 7806                 valNonterminalParser->SetPost(Postval);
 7807             }
 7808             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7809             {
 7810                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7811                 context->value = context->context->MakeSByteValue(cast<SByteType*>(context->fromtype), context->fromval);
 7812             }
 7813             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7814             {
 7815                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7816                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7817             }
 7818             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7819             {
 7820                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7821                 if (matched)
 7822                 {
 7823                     UniquePtr<Object> fromtype_value = stack.Pop();
 7824                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7825                 }
 7826             }
 7827             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7828             {
 7829                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7830                 if (matched)
 7831                 {
 7832                     UniquePtr<Object> fromval_value = stack.Pop();
 7833                     context->fromval = *cast<ValueObject<sbyte>*>(fromval_value.Get());
 7834                 }
 7835             }
 7836             public class Context : System.Text.Parsing.Context
 7837             {
 7838                 public Context() : context(), value(), fromtype(), fromval()
 7839                 {
 7840                 }
 7841                 public cmsx.intermediate.Context* context;
 7842                 public ConstantValue* value;
 7843                 public Type* fromtype;
 7844                 public sbyte fromval;
 7845             }
 7846         }
 7847 
 7848         public class SByteValueRule : System.Text.Parsing.RuleParser
 7849         {
 7850             public SByteValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7851             {
 7852                 SetValueTypeName(ToUtf32("sbyte"));
 7853             }
 7854             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7855             {
 7856                 parsingData->PushContext(Id(), new Context());
 7857                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7858             }
 7859             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7860             {
 7861                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7862                 if (matched)
 7863                 {
 7864                     stack.Push(UniquePtr<Object>(new ValueObject<sbyte>(context->value)));
 7865                 }
 7866                 parsingData->PopContext(Id());
 7867             }
 7868             public override void Link()
 7869             {
 7870                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7871                 a0ActionParser->SetAction(A0Action);
 7872                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 7873                 xNonterminalParser->SetPost(Postx);
 7874             }
 7875             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7876             {
 7877                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7878                 context->value = context->fromx;
 7879             }
 7880             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7881             {
 7882                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7883                 if (matched)
 7884                 {
 7885                     UniquePtr<Object> fromx_value = stack.Pop();
 7886                     context->fromx = *cast<ValueObject<sbyte>*>(fromx_value.Get());
 7887                 }
 7888             }
 7889             public class Context : System.Text.Parsing.Context
 7890             {
 7891                 public Context() : value(), fromx()
 7892                 {
 7893                 }
 7894                 public sbyte value;
 7895                 public sbyte fromx;
 7896             }
 7897         }
 7898 
 7899         public class ByteConstantRule : System.Text.Parsing.RuleParser
 7900         {
 7901             public ByteConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7902             {
 7903                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 7904                 SetValueTypeName(ToUtf32("ConstantValue*"));
 7905             }
 7906             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7907             {
 7908                 parsingData->PushContext(Id(), new Context());
 7909                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7910                 UniquePtr<Object> context_value = stack.Pop();
 7911                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 7912             }
 7913             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7914             {
 7915                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7916                 if (matched)
 7917                 {
 7918                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 7919                 }
 7920                 parsingData->PopContext(Id());
 7921             }
 7922             public override void Link()
 7923             {
 7924                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7925                 a0ActionParser->SetAction(A0Action);
 7926                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 7927                 typeNonterminalParser->SetPre(Pretype);
 7928                 typeNonterminalParser->SetPost(Posttype);
 7929                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 7930                 valNonterminalParser->SetPost(Postval);
 7931             }
 7932             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 7933             {
 7934                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7935                 context->value = context->context->MakeByteValue(cast<ByteType*>(context->fromtype), context->fromval);
 7936             }
 7937             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7938             {
 7939                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7940                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 7941             }
 7942             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7943             {
 7944                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7945                 if (matched)
 7946                 {
 7947                     UniquePtr<Object> fromtype_value = stack.Pop();
 7948                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 7949                 }
 7950             }
 7951             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7952             {
 7953                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7954                 if (matched)
 7955                 {
 7956                     UniquePtr<Object> fromval_value = stack.Pop();
 7957                     context->fromval = *cast<ValueObject<byte>*>(fromval_value.Get());
 7958                 }
 7959             }
 7960             public class Context : System.Text.Parsing.Context
 7961             {
 7962                 public Context() : context(), value(), fromtype(), fromval()
 7963                 {
 7964                 }
 7965                 public cmsx.intermediate.Context* context;
 7966                 public ConstantValue* value;
 7967                 public Type* fromtype;
 7968                 public byte fromval;
 7969             }
 7970         }
 7971 
 7972         public class ByteValueRule : System.Text.Parsing.RuleParser
 7973         {
 7974             public ByteValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 7975             {
 7976                 SetValueTypeName(ToUtf32("byte"));
 7977             }
 7978             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 7979             {
 7980                 parsingData->PushContext(Id(), new Context());
 7981                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7982             }
 7983             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 7984             {
 7985                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 7986                 if (matched)
 7987                 {
 7988                     stack.Push(UniquePtr<Object>(new ValueObject<byte>(context->value)));
 7989                 }
 7990                 parsingData->PopContext(Id());
 7991             }
 7992             public override void Link()
 7993             {
 7994                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 7995                 a0ActionParser->SetAction(A0Action);
 7996                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 7997                 xNonterminalParser->SetPost(Postx);
 7998             }
 7999             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8000             {
 8001                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8002                 context->value = context->fromx;
 8003             }
 8004             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8005             {
 8006                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8007                 if (matched)
 8008                 {
 8009                     UniquePtr<Object> fromx_value = stack.Pop();
 8010                     context->fromx = *cast<ValueObject<byte>*>(fromx_value.Get());
 8011                 }
 8012             }
 8013             public class Context : System.Text.Parsing.Context
 8014             {
 8015                 public Context() : value(), fromx()
 8016                 {
 8017                 }
 8018                 public byte value;
 8019                 public byte fromx;
 8020             }
 8021         }
 8022 
 8023         public class ShortConstantRule : System.Text.Parsing.RuleParser
 8024         {
 8025             public ShortConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8026             {
 8027                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8028                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8029             }
 8030             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8031             {
 8032                 parsingData->PushContext(Id(), new Context());
 8033                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8034                 UniquePtr<Object> context_value = stack.Pop();
 8035                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8036             }
 8037             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8038             {
 8039                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8040                 if (matched)
 8041                 {
 8042                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8043                 }
 8044                 parsingData->PopContext(Id());
 8045             }
 8046             public override void Link()
 8047             {
 8048                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8049                 a0ActionParser->SetAction(A0Action);
 8050                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8051                 typeNonterminalParser->SetPre(Pretype);
 8052                 typeNonterminalParser->SetPost(Posttype);
 8053                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8054                 valNonterminalParser->SetPost(Postval);
 8055             }
 8056             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8057             {
 8058                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8059                 context->value = context->context->MakeShortValue(cast<ShortType*>(context->fromtype), context->fromval);
 8060             }
 8061             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8062             {
 8063                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8064                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8065             }
 8066             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8067             {
 8068                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8069                 if (matched)
 8070                 {
 8071                     UniquePtr<Object> fromtype_value = stack.Pop();
 8072                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8073                 }
 8074             }
 8075             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8076             {
 8077                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8078                 if (matched)
 8079                 {
 8080                     UniquePtr<Object> fromval_value = stack.Pop();
 8081                     context->fromval = *cast<ValueObject<short>*>(fromval_value.Get());
 8082                 }
 8083             }
 8084             public class Context : System.Text.Parsing.Context
 8085             {
 8086                 public Context() : context(), value(), fromtype(), fromval()
 8087                 {
 8088                 }
 8089                 public cmsx.intermediate.Context* context;
 8090                 public ConstantValue* value;
 8091                 public Type* fromtype;
 8092                 public short fromval;
 8093             }
 8094         }
 8095 
 8096         public class ShortValueRule : System.Text.Parsing.RuleParser
 8097         {
 8098             public ShortValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8099             {
 8100                 SetValueTypeName(ToUtf32("short"));
 8101             }
 8102             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8103             {
 8104                 parsingData->PushContext(Id(), new Context());
 8105                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8106             }
 8107             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8108             {
 8109                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8110                 if (matched)
 8111                 {
 8112                     stack.Push(UniquePtr<Object>(new ValueObject<short>(context->value)));
 8113                 }
 8114                 parsingData->PopContext(Id());
 8115             }
 8116             public override void Link()
 8117             {
 8118                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8119                 a0ActionParser->SetAction(A0Action);
 8120                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8121                 xNonterminalParser->SetPost(Postx);
 8122             }
 8123             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8124             {
 8125                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8126                 context->value = context->fromx;
 8127             }
 8128             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8129             {
 8130                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8131                 if (matched)
 8132                 {
 8133                     UniquePtr<Object> fromx_value = stack.Pop();
 8134                     context->fromx = *cast<ValueObject<short>*>(fromx_value.Get());
 8135                 }
 8136             }
 8137             public class Context : System.Text.Parsing.Context
 8138             {
 8139                 public Context() : value(), fromx()
 8140                 {
 8141                 }
 8142                 public short value;
 8143                 public short fromx;
 8144             }
 8145         }
 8146 
 8147         public class UShortConstantRule : System.Text.Parsing.RuleParser
 8148         {
 8149             public UShortConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8150             {
 8151                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8152                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8153             }
 8154             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8155             {
 8156                 parsingData->PushContext(Id(), new Context());
 8157                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8158                 UniquePtr<Object> context_value = stack.Pop();
 8159                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8160             }
 8161             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8162             {
 8163                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8164                 if (matched)
 8165                 {
 8166                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8167                 }
 8168                 parsingData->PopContext(Id());
 8169             }
 8170             public override void Link()
 8171             {
 8172                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8173                 a0ActionParser->SetAction(A0Action);
 8174                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8175                 typeNonterminalParser->SetPre(Pretype);
 8176                 typeNonterminalParser->SetPost(Posttype);
 8177                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8178                 valNonterminalParser->SetPost(Postval);
 8179             }
 8180             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8181             {
 8182                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8183                 context->value = context->context->MakeUShortValue(cast<UShortType*>(context->fromtype), context->fromval);
 8184             }
 8185             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8186             {
 8187                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8188                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8189             }
 8190             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8191             {
 8192                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8193                 if (matched)
 8194                 {
 8195                     UniquePtr<Object> fromtype_value = stack.Pop();
 8196                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8197                 }
 8198             }
 8199             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8200             {
 8201                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8202                 if (matched)
 8203                 {
 8204                     UniquePtr<Object> fromval_value = stack.Pop();
 8205                     context->fromval = *cast<ValueObject<ushort>*>(fromval_value.Get());
 8206                 }
 8207             }
 8208             public class Context : System.Text.Parsing.Context
 8209             {
 8210                 public Context() : context(), value(), fromtype(), fromval()
 8211                 {
 8212                 }
 8213                 public cmsx.intermediate.Context* context;
 8214                 public ConstantValue* value;
 8215                 public Type* fromtype;
 8216                 public ushort fromval;
 8217             }
 8218         }
 8219 
 8220         public class UShortValueRule : System.Text.Parsing.RuleParser
 8221         {
 8222             public UShortValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8223             {
 8224                 SetValueTypeName(ToUtf32("ushort"));
 8225             }
 8226             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8227             {
 8228                 parsingData->PushContext(Id(), new Context());
 8229                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8230             }
 8231             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8232             {
 8233                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8234                 if (matched)
 8235                 {
 8236                     stack.Push(UniquePtr<Object>(new ValueObject<ushort>(context->value)));
 8237                 }
 8238                 parsingData->PopContext(Id());
 8239             }
 8240             public override void Link()
 8241             {
 8242                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8243                 a0ActionParser->SetAction(A0Action);
 8244                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8245                 xNonterminalParser->SetPost(Postx);
 8246             }
 8247             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8248             {
 8249                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8250                 context->value = context->fromx;
 8251             }
 8252             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8253             {
 8254                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8255                 if (matched)
 8256                 {
 8257                     UniquePtr<Object> fromx_value = stack.Pop();
 8258                     context->fromx = *cast<ValueObject<ushort>*>(fromx_value.Get());
 8259                 }
 8260             }
 8261             public class Context : System.Text.Parsing.Context
 8262             {
 8263                 public Context() : value(), fromx()
 8264                 {
 8265                 }
 8266                 public ushort value;
 8267                 public ushort fromx;
 8268             }
 8269         }
 8270 
 8271         public class IntConstantRule : System.Text.Parsing.RuleParser
 8272         {
 8273             public IntConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8274             {
 8275                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8276                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8277             }
 8278             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8279             {
 8280                 parsingData->PushContext(Id(), new Context());
 8281                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8282                 UniquePtr<Object> context_value = stack.Pop();
 8283                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8284             }
 8285             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8286             {
 8287                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8288                 if (matched)
 8289                 {
 8290                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8291                 }
 8292                 parsingData->PopContext(Id());
 8293             }
 8294             public override void Link()
 8295             {
 8296                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8297                 a0ActionParser->SetAction(A0Action);
 8298                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8299                 typeNonterminalParser->SetPre(Pretype);
 8300                 typeNonterminalParser->SetPost(Posttype);
 8301                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8302                 valNonterminalParser->SetPost(Postval);
 8303             }
 8304             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8305             {
 8306                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8307                 context->value = context->context->MakeIntValue(cast<IntType*>(context->fromtype), context->fromval);
 8308             }
 8309             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8310             {
 8311                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8312                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8313             }
 8314             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8315             {
 8316                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8317                 if (matched)
 8318                 {
 8319                     UniquePtr<Object> fromtype_value = stack.Pop();
 8320                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8321                 }
 8322             }
 8323             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8324             {
 8325                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8326                 if (matched)
 8327                 {
 8328                     UniquePtr<Object> fromval_value = stack.Pop();
 8329                     context->fromval = *cast<ValueObject<int>*>(fromval_value.Get());
 8330                 }
 8331             }
 8332             public class Context : System.Text.Parsing.Context
 8333             {
 8334                 public Context() : context(), value(), fromtype(), fromval()
 8335                 {
 8336                 }
 8337                 public cmsx.intermediate.Context* context;
 8338                 public ConstantValue* value;
 8339                 public Type* fromtype;
 8340                 public int fromval;
 8341             }
 8342         }
 8343 
 8344         public class IntValueRule : System.Text.Parsing.RuleParser
 8345         {
 8346             public IntValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8347             {
 8348                 SetValueTypeName(ToUtf32("int"));
 8349             }
 8350             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8351             {
 8352                 parsingData->PushContext(Id(), new Context());
 8353                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8354             }
 8355             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8356             {
 8357                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8358                 if (matched)
 8359                 {
 8360                     stack.Push(UniquePtr<Object>(new ValueObject<int>(context->value)));
 8361                 }
 8362                 parsingData->PopContext(Id());
 8363             }
 8364             public override void Link()
 8365             {
 8366                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8367                 a0ActionParser->SetAction(A0Action);
 8368                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8369                 xNonterminalParser->SetPost(Postx);
 8370             }
 8371             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8372             {
 8373                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8374                 context->value = context->fromx;
 8375             }
 8376             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8377             {
 8378                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8379                 if (matched)
 8380                 {
 8381                     UniquePtr<Object> fromx_value = stack.Pop();
 8382                     context->fromx = *cast<ValueObject<int>*>(fromx_value.Get());
 8383                 }
 8384             }
 8385             public class Context : System.Text.Parsing.Context
 8386             {
 8387                 public Context() : value(), fromx()
 8388                 {
 8389                 }
 8390                 public int value;
 8391                 public int fromx;
 8392             }
 8393         }
 8394 
 8395         public class UIntConstantRule : System.Text.Parsing.RuleParser
 8396         {
 8397             public UIntConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8398             {
 8399                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8400                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8401             }
 8402             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8403             {
 8404                 parsingData->PushContext(Id(), new Context());
 8405                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8406                 UniquePtr<Object> context_value = stack.Pop();
 8407                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8408             }
 8409             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8410             {
 8411                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8412                 if (matched)
 8413                 {
 8414                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8415                 }
 8416                 parsingData->PopContext(Id());
 8417             }
 8418             public override void Link()
 8419             {
 8420                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8421                 a0ActionParser->SetAction(A0Action);
 8422                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8423                 typeNonterminalParser->SetPre(Pretype);
 8424                 typeNonterminalParser->SetPost(Posttype);
 8425                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8426                 valNonterminalParser->SetPost(Postval);
 8427             }
 8428             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8429             {
 8430                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8431                 context->value = context->context->MakeUIntValue(cast<UIntType*>(context->fromtype), context->fromval);
 8432             }
 8433             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8434             {
 8435                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8436                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8437             }
 8438             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8439             {
 8440                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8441                 if (matched)
 8442                 {
 8443                     UniquePtr<Object> fromtype_value = stack.Pop();
 8444                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8445                 }
 8446             }
 8447             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8448             {
 8449                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8450                 if (matched)
 8451                 {
 8452                     UniquePtr<Object> fromval_value = stack.Pop();
 8453                     context->fromval = *cast<ValueObject<uint>*>(fromval_value.Get());
 8454                 }
 8455             }
 8456             public class Context : System.Text.Parsing.Context
 8457             {
 8458                 public Context() : context(), value(), fromtype(), fromval()
 8459                 {
 8460                 }
 8461                 public cmsx.intermediate.Context* context;
 8462                 public ConstantValue* value;
 8463                 public Type* fromtype;
 8464                 public uint fromval;
 8465             }
 8466         }
 8467 
 8468         public class UIntValueRule : System.Text.Parsing.RuleParser
 8469         {
 8470             public UIntValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8471             {
 8472                 SetValueTypeName(ToUtf32("uint"));
 8473             }
 8474             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8475             {
 8476                 parsingData->PushContext(Id(), new Context());
 8477                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8478             }
 8479             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8480             {
 8481                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8482                 if (matched)
 8483                 {
 8484                     stack.Push(UniquePtr<Object>(new ValueObject<uint>(context->value)));
 8485                 }
 8486                 parsingData->PopContext(Id());
 8487             }
 8488             public override void Link()
 8489             {
 8490                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8491                 a0ActionParser->SetAction(A0Action);
 8492                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8493                 xNonterminalParser->SetPost(Postx);
 8494             }
 8495             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8496             {
 8497                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8498                 context->value = context->fromx;
 8499             }
 8500             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8501             {
 8502                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8503                 if (matched)
 8504                 {
 8505                     UniquePtr<Object> fromx_value = stack.Pop();
 8506                     context->fromx = *cast<ValueObject<uint>*>(fromx_value.Get());
 8507                 }
 8508             }
 8509             public class Context : System.Text.Parsing.Context
 8510             {
 8511                 public Context() : value(), fromx()
 8512                 {
 8513                 }
 8514                 public uint value;
 8515                 public uint fromx;
 8516             }
 8517         }
 8518 
 8519         public class LongConstantRule : System.Text.Parsing.RuleParser
 8520         {
 8521             public LongConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8522             {
 8523                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8524                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8525             }
 8526             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8527             {
 8528                 parsingData->PushContext(Id(), new Context());
 8529                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8530                 UniquePtr<Object> context_value = stack.Pop();
 8531                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8532             }
 8533             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8534             {
 8535                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8536                 if (matched)
 8537                 {
 8538                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8539                 }
 8540                 parsingData->PopContext(Id());
 8541             }
 8542             public override void Link()
 8543             {
 8544                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8545                 a0ActionParser->SetAction(A0Action);
 8546                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8547                 typeNonterminalParser->SetPre(Pretype);
 8548                 typeNonterminalParser->SetPost(Posttype);
 8549                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8550                 valNonterminalParser->SetPost(Postval);
 8551             }
 8552             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8553             {
 8554                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8555                 context->value = context->context->MakeLongValue(cast<LongType*>(context->fromtype), context->fromval);
 8556             }
 8557             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8558             {
 8559                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8560                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8561             }
 8562             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8563             {
 8564                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8565                 if (matched)
 8566                 {
 8567                     UniquePtr<Object> fromtype_value = stack.Pop();
 8568                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8569                 }
 8570             }
 8571             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8572             {
 8573                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8574                 if (matched)
 8575                 {
 8576                     UniquePtr<Object> fromval_value = stack.Pop();
 8577                     context->fromval = *cast<ValueObject<long>*>(fromval_value.Get());
 8578                 }
 8579             }
 8580             public class Context : System.Text.Parsing.Context
 8581             {
 8582                 public Context() : context(), value(), fromtype(), fromval()
 8583                 {
 8584                 }
 8585                 public cmsx.intermediate.Context* context;
 8586                 public ConstantValue* value;
 8587                 public Type* fromtype;
 8588                 public long fromval;
 8589             }
 8590         }
 8591 
 8592         public class LongValueRule : System.Text.Parsing.RuleParser
 8593         {
 8594             public LongValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8595             {
 8596                 SetValueTypeName(ToUtf32("long"));
 8597             }
 8598             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8599             {
 8600                 parsingData->PushContext(Id(), new Context());
 8601                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8602             }
 8603             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8604             {
 8605                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8606                 if (matched)
 8607                 {
 8608                     stack.Push(UniquePtr<Object>(new ValueObject<long>(context->value)));
 8609                 }
 8610                 parsingData->PopContext(Id());
 8611             }
 8612             public override void Link()
 8613             {
 8614                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8615                 a0ActionParser->SetAction(A0Action);
 8616                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8617                 xNonterminalParser->SetPost(Postx);
 8618             }
 8619             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8620             {
 8621                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8622                 context->value = context->fromx;
 8623             }
 8624             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8625             {
 8626                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8627                 if (matched)
 8628                 {
 8629                     UniquePtr<Object> fromx_value = stack.Pop();
 8630                     context->fromx = *cast<ValueObject<long>*>(fromx_value.Get());
 8631                 }
 8632             }
 8633             public class Context : System.Text.Parsing.Context
 8634             {
 8635                 public Context() : value(), fromx()
 8636                 {
 8637                 }
 8638                 public long value;
 8639                 public long fromx;
 8640             }
 8641         }
 8642 
 8643         public class ULongConstantRule : System.Text.Parsing.RuleParser
 8644         {
 8645             public ULongConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8646             {
 8647                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8648                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8649             }
 8650             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8651             {
 8652                 parsingData->PushContext(Id(), new Context());
 8653                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8654                 UniquePtr<Object> context_value = stack.Pop();
 8655                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8656             }
 8657             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8658             {
 8659                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8660                 if (matched)
 8661                 {
 8662                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8663                 }
 8664                 parsingData->PopContext(Id());
 8665             }
 8666             public override void Link()
 8667             {
 8668                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8669                 a0ActionParser->SetAction(A0Action);
 8670                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8671                 typeNonterminalParser->SetPre(Pretype);
 8672                 typeNonterminalParser->SetPost(Posttype);
 8673                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8674                 valNonterminalParser->SetPost(Postval);
 8675             }
 8676             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8677             {
 8678                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8679                 context->value = context->context->MakeULongValue(cast<ULongType*>(context->fromtype), context->fromval);
 8680             }
 8681             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8682             {
 8683                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8684                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8685             }
 8686             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8687             {
 8688                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8689                 if (matched)
 8690                 {
 8691                     UniquePtr<Object> fromtype_value = stack.Pop();
 8692                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8693                 }
 8694             }
 8695             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8696             {
 8697                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8698                 if (matched)
 8699                 {
 8700                     UniquePtr<Object> fromval_value = stack.Pop();
 8701                     context->fromval = *cast<ValueObject<ulong>*>(fromval_value.Get());
 8702                 }
 8703             }
 8704             public class Context : System.Text.Parsing.Context
 8705             {
 8706                 public Context() : context(), value(), fromtype(), fromval()
 8707                 {
 8708                 }
 8709                 public cmsx.intermediate.Context* context;
 8710                 public ConstantValue* value;
 8711                 public Type* fromtype;
 8712                 public ulong fromval;
 8713             }
 8714         }
 8715 
 8716         public class ULongValueRule : System.Text.Parsing.RuleParser
 8717         {
 8718             public ULongValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8719             {
 8720                 SetValueTypeName(ToUtf32("ulong"));
 8721             }
 8722             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8723             {
 8724                 parsingData->PushContext(Id(), new Context());
 8725                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8726             }
 8727             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8728             {
 8729                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8730                 if (matched)
 8731                 {
 8732                     stack.Push(UniquePtr<Object>(new ValueObject<ulong>(context->value)));
 8733                 }
 8734                 parsingData->PopContext(Id());
 8735             }
 8736             public override void Link()
 8737             {
 8738                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8739                 a0ActionParser->SetAction(A0Action);
 8740                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8741                 xNonterminalParser->SetPost(Postx);
 8742             }
 8743             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8744             {
 8745                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8746                 context->value = context->fromx;
 8747             }
 8748             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8749             {
 8750                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8751                 if (matched)
 8752                 {
 8753                     UniquePtr<Object> fromx_value = stack.Pop();
 8754                     context->fromx = *cast<ValueObject<ulong>*>(fromx_value.Get());
 8755                 }
 8756             }
 8757             public class Context : System.Text.Parsing.Context
 8758             {
 8759                 public Context() : value(), fromx()
 8760                 {
 8761                 }
 8762                 public ulong value;
 8763                 public ulong fromx;
 8764             }
 8765         }
 8766 
 8767         public class FloatConstantRule : System.Text.Parsing.RuleParser
 8768         {
 8769             public FloatConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8770             {
 8771                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8772                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8773             }
 8774             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8775             {
 8776                 parsingData->PushContext(Id(), new Context());
 8777                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8778                 UniquePtr<Object> context_value = stack.Pop();
 8779                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8780             }
 8781             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8782             {
 8783                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8784                 if (matched)
 8785                 {
 8786                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8787                 }
 8788                 parsingData->PopContext(Id());
 8789             }
 8790             public override void Link()
 8791             {
 8792                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8793                 a0ActionParser->SetAction(A0Action);
 8794                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8795                 typeNonterminalParser->SetPre(Pretype);
 8796                 typeNonterminalParser->SetPost(Posttype);
 8797                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8798                 valNonterminalParser->SetPost(Postval);
 8799             }
 8800             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8801             {
 8802                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8803                 context->value = context->context->MakeFloatValue(cast<FloatType*>(context->fromtype), context->fromval);
 8804             }
 8805             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8806             {
 8807                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8808                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8809             }
 8810             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8811             {
 8812                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8813                 if (matched)
 8814                 {
 8815                     UniquePtr<Object> fromtype_value = stack.Pop();
 8816                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8817                 }
 8818             }
 8819             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8820             {
 8821                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8822                 if (matched)
 8823                 {
 8824                     UniquePtr<Object> fromval_value = stack.Pop();
 8825                     context->fromval = *cast<ValueObject<float>*>(fromval_value.Get());
 8826                 }
 8827             }
 8828             public class Context : System.Text.Parsing.Context
 8829             {
 8830                 public Context() : context(), value(), fromtype(), fromval()
 8831                 {
 8832                 }
 8833                 public cmsx.intermediate.Context* context;
 8834                 public ConstantValue* value;
 8835                 public Type* fromtype;
 8836                 public float fromval;
 8837             }
 8838         }
 8839 
 8840         public class FloatValueRule : System.Text.Parsing.RuleParser
 8841         {
 8842             public FloatValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8843             {
 8844                 SetValueTypeName(ToUtf32("float"));
 8845             }
 8846             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8847             {
 8848                 parsingData->PushContext(Id(), new Context());
 8849                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8850             }
 8851             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8852             {
 8853                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8854                 if (matched)
 8855                 {
 8856                     stack.Push(UniquePtr<Object>(new ValueObject<float>(context->value)));
 8857                 }
 8858                 parsingData->PopContext(Id());
 8859             }
 8860             public override void Link()
 8861             {
 8862                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8863                 a0ActionParser->SetAction(A0Action);
 8864                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8865                 xNonterminalParser->SetPost(Postx);
 8866             }
 8867             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8868             {
 8869                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8870                 context->value = context->fromx;
 8871             }
 8872             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8873             {
 8874                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8875                 if (matched)
 8876                 {
 8877                     UniquePtr<Object> fromx_value = stack.Pop();
 8878                     context->fromx = *cast<ValueObject<float>*>(fromx_value.Get());
 8879                 }
 8880             }
 8881             public class Context : System.Text.Parsing.Context
 8882             {
 8883                 public Context() : value(), fromx()
 8884                 {
 8885                 }
 8886                 public float value;
 8887                 public float fromx;
 8888             }
 8889         }
 8890 
 8891         public class DoubleConstantRule : System.Text.Parsing.RuleParser
 8892         {
 8893             public DoubleConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8894             {
 8895                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 8896                 SetValueTypeName(ToUtf32("ConstantValue*"));
 8897             }
 8898             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8899             {
 8900                 parsingData->PushContext(Id(), new Context());
 8901                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8902                 UniquePtr<Object> context_value = stack.Pop();
 8903                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 8904             }
 8905             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8906             {
 8907                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8908                 if (matched)
 8909                 {
 8910                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 8911                 }
 8912                 parsingData->PopContext(Id());
 8913             }
 8914             public override void Link()
 8915             {
 8916                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8917                 a0ActionParser->SetAction(A0Action);
 8918                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 8919                 typeNonterminalParser->SetPre(Pretype);
 8920                 typeNonterminalParser->SetPost(Posttype);
 8921                 NonterminalParser* valNonterminalParser = GetNonterminal(ToUtf32("val"));
 8922                 valNonterminalParser->SetPost(Postval);
 8923             }
 8924             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8925             {
 8926                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8927                 context->value = context->context->MakeDoubleValue(cast<DoubleType*>(context->fromtype), context->fromval);
 8928             }
 8929             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8930             {
 8931                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8932                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 8933             }
 8934             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8935             {
 8936                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8937                 if (matched)
 8938                 {
 8939                     UniquePtr<Object> fromtype_value = stack.Pop();
 8940                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 8941                 }
 8942             }
 8943             public void Postval(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8944             {
 8945                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8946                 if (matched)
 8947                 {
 8948                     UniquePtr<Object> fromval_value = stack.Pop();
 8949                     context->fromval = *cast<ValueObject<double>*>(fromval_value.Get());
 8950                 }
 8951             }
 8952             public class Context : System.Text.Parsing.Context
 8953             {
 8954                 public Context() : context(), value(), fromtype(), fromval()
 8955                 {
 8956                 }
 8957                 public cmsx.intermediate.Context* context;
 8958                 public ConstantValue* value;
 8959                 public Type* fromtype;
 8960                 public double fromval;
 8961             }
 8962         }
 8963 
 8964         public class DoubleValueRule : System.Text.Parsing.RuleParser
 8965         {
 8966             public DoubleValueRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 8967             {
 8968                 SetValueTypeName(ToUtf32("double"));
 8969             }
 8970             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 8971             {
 8972                 parsingData->PushContext(Id(), new Context());
 8973                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8974             }
 8975             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8976             {
 8977                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8978                 if (matched)
 8979                 {
 8980                     stack.Push(UniquePtr<Object>(new ValueObject<double>(context->value)));
 8981                 }
 8982                 parsingData->PopContext(Id());
 8983             }
 8984             public override void Link()
 8985             {
 8986                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 8987                 a0ActionParser->SetAction(A0Action);
 8988                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 8989                 xNonterminalParser->SetPost(Postx);
 8990             }
 8991             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 8992             {
 8993                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8994                 context->value = context->fromx;
 8995             }
 8996             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 8997             {
 8998                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 8999                 if (matched)
 9000                 {
 9001                     UniquePtr<Object> fromx_value = stack.Pop();
 9002                     context->fromx = *cast<ValueObject<double>*>(fromx_value.Get());
 9003                 }
 9004             }
 9005             public class Context : System.Text.Parsing.Context
 9006             {
 9007                 public Context() : value(), fromx()
 9008                 {
 9009                 }
 9010                 public double value;
 9011                 public double fromx;
 9012             }
 9013         }
 9014 
 9015         public class ConversionConstantRule : System.Text.Parsing.RuleParser
 9016         {
 9017             public ConversionConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9018             {
 9019                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9020                 SetValueTypeName(ToUtf32("ConstantValue*"));
 9021             }
 9022             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9023             {
 9024                 parsingData->PushContext(Id(), new Context());
 9025                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9026                 UniquePtr<Object> context_value = stack.Pop();
 9027                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9028             }
 9029             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9030             {
 9031                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9032                 if (matched)
 9033                 {
 9034                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 9035                 }
 9036                 parsingData->PopContext(Id());
 9037             }
 9038             public override void Link()
 9039             {
 9040                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9041                 a0ActionParser->SetAction(A0Action);
 9042                 NonterminalParser* targetTypeNonterminalParser = GetNonterminal(ToUtf32("targetType"));
 9043                 targetTypeNonterminalParser->SetPre(PretargetType);
 9044                 targetTypeNonterminalParser->SetPost(PosttargetType);
 9045                 NonterminalParser* fromNonterminalParser = GetNonterminal(ToUtf32("from"));
 9046                 fromNonterminalParser->SetPre(Prefrom);
 9047                 fromNonterminalParser->SetPost(Postfrom);
 9048             }
 9049             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9050             {
 9051                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9052                 context->value = context->context->MakeConversionValue(context->fromtargetType, context->fromfrom, span.lineNumber);
 9053             }
 9054             public void PretargetType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9055             {
 9056                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9057                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9058             }
 9059             public void PosttargetType(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9060             {
 9061                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9062                 if (matched)
 9063                 {
 9064                     UniquePtr<Object> fromtargetType_value = stack.Pop();
 9065                     context->fromtargetType = *cast<ValueObject<Type*>*>(fromtargetType_value.Get());
 9066                 }
 9067             }
 9068             public void Prefrom(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9069             {
 9070                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9071                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9072             }
 9073             public void Postfrom(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9074             {
 9075                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9076                 if (matched)
 9077                 {
 9078                     UniquePtr<Object> fromfrom_value = stack.Pop();
 9079                     context->fromfrom = *cast<ValueObject<ConstantValue*>*>(fromfrom_value.Get());
 9080                 }
 9081             }
 9082             public class Context : System.Text.Parsing.Context
 9083             {
 9084                 public Context() : context(), value(), fromtargetType(), fromfrom()
 9085                 {
 9086                 }
 9087                 public cmsx.intermediate.Context* context;
 9088                 public ConstantValue* value;
 9089                 public Type* fromtargetType;
 9090                 public ConstantValue* fromfrom;
 9091             }
 9092         }
 9093 
 9094         public class ClsIdConstantRule : System.Text.Parsing.RuleParser
 9095         {
 9096             public ClsIdConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9097             {
 9098                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9099                 SetValueTypeName(ToUtf32("ConstantValue*"));
 9100             }
 9101             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9102             {
 9103                 parsingData->PushContext(Id(), new Context());
 9104                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9105                 UniquePtr<Object> context_value = stack.Pop();
 9106                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9107             }
 9108             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9109             {
 9110                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9111                 if (matched)
 9112                 {
 9113                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 9114                 }
 9115                 parsingData->PopContext(Id());
 9116             }
 9117             public override void Link()
 9118             {
 9119                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9120                 a0ActionParser->SetAction(A0Action);
 9121                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 9122                 typeNonterminalParser->SetPre(Pretype);
 9123                 typeNonterminalParser->SetPost(Posttype);
 9124             }
 9125             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9126             {
 9127                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9128                 context->value = context->context->MakeClsIdValue(context->fromtype, ToUtf8(ustring(matchBegin, matchEnd)), span.lineNumber);
 9129             }
 9130             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9131             {
 9132                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9133                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9134             }
 9135             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9136             {
 9137                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9138                 if (matched)
 9139                 {
 9140                     UniquePtr<Object> fromtype_value = stack.Pop();
 9141                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 9142                 }
 9143             }
 9144             public class Context : System.Text.Parsing.Context
 9145             {
 9146                 public Context() : context(), value(), fromtype()
 9147                 {
 9148                 }
 9149                 public cmsx.intermediate.Context* context;
 9150                 public ConstantValue* value;
 9151                 public Type* fromtype;
 9152             }
 9153         }
 9154 
 9155         public class PtrConstantRule : System.Text.Parsing.RuleParser
 9156         {
 9157             public PtrConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9158             {
 9159                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9160                 SetValueTypeName(ToUtf32("ConstantValue*"));
 9161             }
 9162             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9163             {
 9164                 parsingData->PushContext(Id(), new Context());
 9165                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9166                 UniquePtr<Object> context_value = stack.Pop();
 9167                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9168             }
 9169             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9170             {
 9171                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9172                 if (matched)
 9173                 {
 9174                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 9175                 }
 9176                 parsingData->PopContext(Id());
 9177             }
 9178             public override void Link()
 9179             {
 9180                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9181                 a0ActionParser->SetAction(A0Action);
 9182                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 9183                 a1ActionParser->SetAction(A1Action);
 9184                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 9185                 a2ActionParser->SetAction(A2Action);
 9186                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 9187                 a3ActionParser->SetAction(A3Action);
 9188                 NonterminalParser* type1NonterminalParser = GetNonterminal(ToUtf32("type1"));
 9189                 type1NonterminalParser->SetPre(Pretype1);
 9190                 type1NonterminalParser->SetPost(Posttype1);
 9191                 NonterminalParser* type2NonterminalParser = GetNonterminal(ToUtf32("type2"));
 9192                 type2NonterminalParser->SetPre(Pretype2);
 9193                 type2NonterminalParser->SetPost(Posttype2);
 9194                 NonterminalParser* literalValueNonterminalParser = GetNonterminal(ToUtf32("LiteralValue"));
 9195                 literalValueNonterminalParser->SetPre(PreLiteralValue);
 9196                 literalValueNonterminalParser->SetPost(PostLiteralValue);
 9197             }
 9198             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9199             {
 9200                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9201                 context->value = cast<PtrType*>(context->fromtype1)->DefaultValue();
 9202             }
 9203             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9204             {
 9205                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9206                 pass = IsPtrType(context->fromtype1);
 9207             }
 9208             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9209             {
 9210                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9211                 context->value = context->fromLiteralValue;
 9212             }
 9213             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9214             {
 9215                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9216                 pass = IsPtrType(context->fromtype2);
 9217             }
 9218             public void Pretype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9219             {
 9220                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9221                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9222             }
 9223             public void Posttype1(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9224             {
 9225                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9226                 if (matched)
 9227                 {
 9228                     UniquePtr<Object> fromtype1_value = stack.Pop();
 9229                     context->fromtype1 = *cast<ValueObject<Type*>*>(fromtype1_value.Get());
 9230                 }
 9231             }
 9232             public void Pretype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9233             {
 9234                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9235                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9236             }
 9237             public void Posttype2(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9238             {
 9239                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9240                 if (matched)
 9241                 {
 9242                     UniquePtr<Object> fromtype2_value = stack.Pop();
 9243                     context->fromtype2 = *cast<ValueObject<Type*>*>(fromtype2_value.Get());
 9244                 }
 9245             }
 9246             public void PreLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9247             {
 9248                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9249                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9250                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype2)));
 9251             }
 9252             public void PostLiteralValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9253             {
 9254                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9255                 if (matched)
 9256                 {
 9257                     UniquePtr<Object> fromLiteralValue_value = stack.Pop();
 9258                     context->fromLiteralValue = *cast<ValueObject<ConstantValue*>*>(fromLiteralValue_value.Get());
 9259                 }
 9260             }
 9261             public class Context : System.Text.Parsing.Context
 9262             {
 9263                 public Context() : context(), value(), fromtype1(), fromtype2(), fromLiteralValue()
 9264                 {
 9265                 }
 9266                 public cmsx.intermediate.Context* context;
 9267                 public ConstantValue* value;
 9268                 public Type* fromtype1;
 9269                 public Type* fromtype2;
 9270                 public ConstantValue* fromLiteralValue;
 9271             }
 9272         }
 9273 
 9274         public class SymbolConstantRule : System.Text.Parsing.RuleParser
 9275         {
 9276             public SymbolConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9277             {
 9278                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9279                 SetValueTypeName(ToUtf32("ConstantValue*"));
 9280             }
 9281             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9282             {
 9283                 parsingData->PushContext(Id(), new Context());
 9284                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9285                 UniquePtr<Object> context_value = stack.Pop();
 9286                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9287             }
 9288             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9289             {
 9290                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9291                 if (matched)
 9292                 {
 9293                     stack.Push(UniquePtr<Object>(new ValueObject<ConstantValue*>(context->value)));
 9294                 }
 9295                 parsingData->PopContext(Id());
 9296             }
 9297             public override void Link()
 9298             {
 9299                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9300                 a0ActionParser->SetAction(A0Action);
 9301                 NonterminalParser* typeNonterminalParser = GetNonterminal(ToUtf32("type"));
 9302                 typeNonterminalParser->SetPre(Pretype);
 9303                 typeNonterminalParser->SetPost(Posttype);
 9304                 NonterminalParser* symbolValueNonterminalParser = GetNonterminal(ToUtf32("SymbolValue"));
 9305                 symbolValueNonterminalParser->SetPre(PreSymbolValue);
 9306                 symbolValueNonterminalParser->SetPost(PostSymbolValue);
 9307             }
 9308             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9309             {
 9310                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9311                 context->value = context->fromSymbolValue;
 9312             }
 9313             public void Pretype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9314             {
 9315                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9316                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9317             }
 9318             public void Posttype(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9319             {
 9320                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9321                 if (matched)
 9322                 {
 9323                     UniquePtr<Object> fromtype_value = stack.Pop();
 9324                     context->fromtype = *cast<ValueObject<Type*>*>(fromtype_value.Get());
 9325                 }
 9326             }
 9327             public void PreSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9328             {
 9329                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9330                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9331                 stack.Push(UniquePtr<Object>(new ValueObject<Type*>(context->fromtype)));
 9332             }
 9333             public void PostSymbolValue(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9334             {
 9335                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9336                 if (matched)
 9337                 {
 9338                     UniquePtr<Object> fromSymbolValue_value = stack.Pop();
 9339                     context->fromSymbolValue = *cast<ValueObject<ConstantValue*>*>(fromSymbolValue_value.Get());
 9340                 }
 9341             }
 9342             public class Context : System.Text.Parsing.Context
 9343             {
 9344                 public Context() : context(), value(), fromtype(), fromSymbolValue()
 9345                 {
 9346                 }
 9347                 public cmsx.intermediate.Context* context;
 9348                 public ConstantValue* value;
 9349                 public Type* fromtype;
 9350                 public ConstantValue* fromSymbolValue;
 9351             }
 9352         }
 9353 
 9354         public class ArrayConstantRule : System.Text.Parsing.RuleParser
 9355         {
 9356             public ArrayConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9357             {
 9358                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9359                 SetValueTypeName(ToUtf32("ArrayValue*"));
 9360             }
 9361             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9362             {
 9363                 parsingData->PushContext(Id(), new Context());
 9364                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9365                 UniquePtr<Object> context_value = stack.Pop();
 9366                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9367             }
 9368             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9369             {
 9370                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9371                 if (matched)
 9372                 {
 9373                     stack.Push(UniquePtr<Object>(new ValueObject<ArrayValue*>(context->value)));
 9374                 }
 9375                 parsingData->PopContext(Id());
 9376             }
 9377             public override void Link()
 9378             {
 9379                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9380                 a0ActionParser->SetAction(A0Action);
 9381                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 9382                 a1ActionParser->SetAction(A1Action);
 9383                 NonterminalParser* elementNonterminalParser = GetNonterminal(ToUtf32("element"));
 9384                 elementNonterminalParser->SetPre(Preelement);
 9385                 elementNonterminalParser->SetPost(Postelement);
 9386             }
 9387             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9388             {
 9389                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9390                 context->value = context->context->MakeArrayValue();
 9391             }
 9392             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9393             {
 9394                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9395                 context->value->AddElement(context->fromelement);
 9396             }
 9397             public void Preelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9398             {
 9399                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9400                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9401             }
 9402             public void Postelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9403             {
 9404                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9405                 if (matched)
 9406                 {
 9407                     UniquePtr<Object> fromelement_value = stack.Pop();
 9408                     context->fromelement = *cast<ValueObject<ConstantValue*>*>(fromelement_value.Get());
 9409                 }
 9410             }
 9411             public class Context : System.Text.Parsing.Context
 9412             {
 9413                 public Context() : context(), value(), fromelement()
 9414                 {
 9415                 }
 9416                 public cmsx.intermediate.Context* context;
 9417                 public ArrayValue* value;
 9418                 public ConstantValue* fromelement;
 9419             }
 9420         }
 9421 
 9422         public class StructureConstantRule : System.Text.Parsing.RuleParser
 9423         {
 9424             public StructureConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9425             {
 9426                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9427                 SetValueTypeName(ToUtf32("StructureValue*"));
 9428             }
 9429             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9430             {
 9431                 parsingData->PushContext(Id(), new Context());
 9432                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9433                 UniquePtr<Object> context_value = stack.Pop();
 9434                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9435             }
 9436             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9437             {
 9438                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9439                 if (matched)
 9440                 {
 9441                     stack.Push(UniquePtr<Object>(new ValueObject<StructureValue*>(context->value)));
 9442                 }
 9443                 parsingData->PopContext(Id());
 9444             }
 9445             public override void Link()
 9446             {
 9447                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9448                 a0ActionParser->SetAction(A0Action);
 9449                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 9450                 a1ActionParser->SetAction(A1Action);
 9451                 NonterminalParser* memberNonterminalParser = GetNonterminal(ToUtf32("member"));
 9452                 memberNonterminalParser->SetPre(Premember);
 9453                 memberNonterminalParser->SetPost(Postmember);
 9454             }
 9455             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9456             {
 9457                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9458                 context->value = context->context->MakeStructureValue();
 9459             }
 9460             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9461             {
 9462                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9463                 context->value->AddMember(context->frommember);
 9464             }
 9465             public void Premember(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9466             {
 9467                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9468                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9469             }
 9470             public void Postmember(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9471             {
 9472                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9473                 if (matched)
 9474                 {
 9475                     UniquePtr<Object> frommember_value = stack.Pop();
 9476                     context->frommember = *cast<ValueObject<ConstantValue*>*>(frommember_value.Get());
 9477                 }
 9478             }
 9479             public class Context : System.Text.Parsing.Context
 9480             {
 9481                 public Context() : context(), value(), frommember()
 9482                 {
 9483                 }
 9484                 public cmsx.intermediate.Context* context;
 9485                 public StructureValue* value;
 9486                 public ConstantValue* frommember;
 9487             }
 9488         }
 9489 
 9490         public class StringConstantRule : System.Text.Parsing.RuleParser
 9491         {
 9492             public StringConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9493             {
 9494                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9495                 SetValueTypeName(ToUtf32("StringValue*"));
 9496             }
 9497             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9498             {
 9499                 parsingData->PushContext(Id(), new Context());
 9500                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9501                 UniquePtr<Object> context_value = stack.Pop();
 9502                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9503             }
 9504             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9505             {
 9506                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9507                 if (matched)
 9508                 {
 9509                     stack.Push(UniquePtr<Object>(new ValueObject<StringValue*>(context->value)));
 9510                 }
 9511                 parsingData->PopContext(Id());
 9512             }
 9513             public override void Link()
 9514             {
 9515                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9516                 a0ActionParser->SetAction(A0Action);
 9517             }
 9518             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9519             {
 9520                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9521                 context->value = context->context->MakeStringValue(ToUtf8(ustring(matchBegin, matchEnd)));
 9522             }
 9523             public class Context : System.Text.Parsing.Context
 9524             {
 9525                 public Context() : context(), value()
 9526                 {
 9527                 }
 9528                 public cmsx.intermediate.Context* context;
 9529                 public StringValue* value;
 9530             }
 9531         }
 9532 
 9533         public class StringArrayConstantRule : System.Text.Parsing.RuleParser
 9534         {
 9535             public StringArrayConstantRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9536             {
 9537                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9538                 SetValueTypeName(ToUtf32("StringArrayValue*"));
 9539             }
 9540             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9541             {
 9542                 parsingData->PushContext(Id(), new Context());
 9543                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9544                 UniquePtr<Object> context_value = stack.Pop();
 9545                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9546             }
 9547             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9548             {
 9549                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9550                 if (matched)
 9551                 {
 9552                     stack.Push(UniquePtr<Object>(new ValueObject<StringArrayValue*>(context->value)));
 9553                 }
 9554                 parsingData->PopContext(Id());
 9555             }
 9556             public override void Link()
 9557             {
 9558                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9559                 a0ActionParser->SetAction(A0Action);
 9560                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 9561                 a1ActionParser->SetAction(A1Action);
 9562                 NonterminalParser* prefixNonterminalParser = GetNonterminal(ToUtf32("prefix"));
 9563                 prefixNonterminalParser->SetPost(Postprefix);
 9564                 NonterminalParser* elementNonterminalParser = GetNonterminal(ToUtf32("element"));
 9565                 elementNonterminalParser->SetPre(Preelement);
 9566                 elementNonterminalParser->SetPost(Postelement);
 9567             }
 9568             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9569             {
 9570                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9571                 context->value = context->context->MakeStringArrayValue(context->fromprefix);
 9572             }
 9573             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9574             {
 9575                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9576                 context->value->AddElement(context->fromelement);
 9577             }
 9578             public void Postprefix(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9579             {
 9580                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9581                 if (matched)
 9582                 {
 9583                     UniquePtr<Object> fromprefix_value = stack.Pop();
 9584                     context->fromprefix = *cast<ValueObject<char>*>(fromprefix_value.Get());
 9585                 }
 9586             }
 9587             public void Preelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9588             {
 9589                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9590                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9591             }
 9592             public void Postelement(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9593             {
 9594                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9595                 if (matched)
 9596                 {
 9597                     UniquePtr<Object> fromelement_value = stack.Pop();
 9598                     context->fromelement = *cast<ValueObject<ConstantValue*>*>(fromelement_value.Get());
 9599                 }
 9600             }
 9601             public class Context : System.Text.Parsing.Context
 9602             {
 9603                 public Context() : context(), value(), fromprefix(), fromelement()
 9604                 {
 9605                 }
 9606                 public cmsx.intermediate.Context* context;
 9607                 public StringArrayValue* value;
 9608                 public char fromprefix;
 9609                 public ConstantValue* fromelement;
 9610             }
 9611         }
 9612 
 9613         public class StringArrayPrefixRule : System.Text.Parsing.RuleParser
 9614         {
 9615             public StringArrayPrefixRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9616             {
 9617                 SetValueTypeName(ToUtf32("char"));
 9618             }
 9619             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9620             {
 9621                 parsingData->PushContext(Id(), new Context());
 9622                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9623             }
 9624             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9625             {
 9626                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9627                 if (matched)
 9628                 {
 9629                     stack.Push(UniquePtr<Object>(new ValueObject<char>(context->value)));
 9630                 }
 9631                 parsingData->PopContext(Id());
 9632             }
 9633             public override void Link()
 9634             {
 9635                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9636                 a0ActionParser->SetAction(A0Action);
 9637                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 9638                 a1ActionParser->SetAction(A1Action);
 9639                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 9640                 a2ActionParser->SetAction(A2Action);
 9641             }
 9642             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9643             {
 9644                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9645                 context->value = 'w';
 9646             }
 9647             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9648             {
 9649                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9650                 context->value = 'u';
 9651             }
 9652             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9653             {
 9654                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9655                 context->value = 'b';
 9656             }
 9657             public class Context : System.Text.Parsing.Context
 9658             {
 9659                 public Context() : value()
 9660                 {
 9661                 }
 9662                 public char value;
 9663             }
 9664         }
 9665 
 9666         public class MetadataRule : System.Text.Parsing.RuleParser
 9667         {
 9668             public MetadataRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9669             {
 9670                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9671             }
 9672             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9673             {
 9674                 parsingData->PushContext(Id(), new Context());
 9675                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9676                 UniquePtr<Object> context_value = stack.Pop();
 9677                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9678             }
 9679             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9680             {
 9681                 parsingData->PopContext(Id());
 9682             }
 9683             public override void Link()
 9684             {
 9685                 NonterminalParser* mDStructNonterminalParser = GetNonterminal(ToUtf32("MDStruct"));
 9686                 mDStructNonterminalParser->SetPre(PreMDStruct);
 9687                 mDStructNonterminalParser->SetPost(PostMDStruct);
 9688             }
 9689             public void PreMDStruct(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9690             {
 9691                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9692                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9693             }
 9694             public void PostMDStruct(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9695             {
 9696                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9697                 if (matched)
 9698                 {
 9699                     UniquePtr<Object> fromMDStruct_value = stack.Pop();
 9700                     context->fromMDStruct = *cast<ValueObject<MDStruct*>*>(fromMDStruct_value.Get());
 9701                 }
 9702             }
 9703             public class Context : System.Text.Parsing.Context
 9704             {
 9705                 public Context() : context(), fromMDStruct()
 9706                 {
 9707                 }
 9708                 public cmsx.intermediate.Context* context;
 9709                 public MDStruct* fromMDStruct;
 9710             }
 9711         }
 9712 
 9713         public class MDItemRule : System.Text.Parsing.RuleParser
 9714         {
 9715             public MDItemRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9716             {
 9717                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9718                 SetValueTypeName(ToUtf32("MDItem*"));
 9719             }
 9720             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9721             {
 9722                 parsingData->PushContext(Id(), new Context());
 9723                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9724                 UniquePtr<Object> context_value = stack.Pop();
 9725                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9726             }
 9727             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9728             {
 9729                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9730                 if (matched)
 9731                 {
 9732                     stack.Push(UniquePtr<Object>(new ValueObject<MDItem*>(context->value)));
 9733                 }
 9734                 parsingData->PopContext(Id());
 9735             }
 9736             public override void Link()
 9737             {
 9738                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9739                 a0ActionParser->SetAction(A0Action);
 9740                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 9741                 a1ActionParser->SetAction(A1Action);
 9742                 ActionParser* a2ActionParser = GetAction(ToUtf32("A2"));
 9743                 a2ActionParser->SetAction(A2Action);
 9744                 ActionParser* a3ActionParser = GetAction(ToUtf32("A3"));
 9745                 a3ActionParser->SetAction(A3Action);
 9746                 NonterminalParser* mDBoolNonterminalParser = GetNonterminal(ToUtf32("MDBool"));
 9747                 mDBoolNonterminalParser->SetPre(PreMDBool);
 9748                 mDBoolNonterminalParser->SetPost(PostMDBool);
 9749                 NonterminalParser* mDLongNonterminalParser = GetNonterminal(ToUtf32("MDLong"));
 9750                 mDLongNonterminalParser->SetPre(PreMDLong);
 9751                 mDLongNonterminalParser->SetPost(PostMDLong);
 9752                 NonterminalParser* mDStringNonterminalParser = GetNonterminal(ToUtf32("MDString"));
 9753                 mDStringNonterminalParser->SetPre(PreMDString);
 9754                 mDStringNonterminalParser->SetPost(PostMDString);
 9755                 NonterminalParser* mDStructRefNonterminalParser = GetNonterminal(ToUtf32("MDStructRef"));
 9756                 mDStructRefNonterminalParser->SetPre(PreMDStructRef);
 9757                 mDStructRefNonterminalParser->SetPost(PostMDStructRef);
 9758             }
 9759             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9760             {
 9761                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9762                 context->value = context->fromMDBool;
 9763             }
 9764             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9765             {
 9766                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9767                 context->value = context->fromMDLong;
 9768             }
 9769             public void A2Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9770             {
 9771                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9772                 context->value = context->fromMDString;
 9773             }
 9774             public void A3Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9775             {
 9776                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9777                 context->value = context->fromMDStructRef;
 9778             }
 9779             public void PreMDBool(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9780             {
 9781                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9782                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9783             }
 9784             public void PostMDBool(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9785             {
 9786                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9787                 if (matched)
 9788                 {
 9789                     UniquePtr<Object> fromMDBool_value = stack.Pop();
 9790                     context->fromMDBool = *cast<ValueObject<MDBool*>*>(fromMDBool_value.Get());
 9791                 }
 9792             }
 9793             public void PreMDLong(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9794             {
 9795                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9796                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9797             }
 9798             public void PostMDLong(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9799             {
 9800                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9801                 if (matched)
 9802                 {
 9803                     UniquePtr<Object> fromMDLong_value = stack.Pop();
 9804                     context->fromMDLong = *cast<ValueObject<MDLong*>*>(fromMDLong_value.Get());
 9805                 }
 9806             }
 9807             public void PreMDString(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9808             {
 9809                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9810                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9811             }
 9812             public void PostMDString(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9813             {
 9814                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9815                 if (matched)
 9816                 {
 9817                     UniquePtr<Object> fromMDString_value = stack.Pop();
 9818                     context->fromMDString = *cast<ValueObject<MDString*>*>(fromMDString_value.Get());
 9819                 }
 9820             }
 9821             public void PreMDStructRef(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9822             {
 9823                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9824                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
 9825             }
 9826             public void PostMDStructRef(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9827             {
 9828                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9829                 if (matched)
 9830                 {
 9831                     UniquePtr<Object> fromMDStructRef_value = stack.Pop();
 9832                     context->fromMDStructRef = *cast<ValueObject<MDStructRef*>*>(fromMDStructRef_value.Get());
 9833                 }
 9834             }
 9835             public class Context : System.Text.Parsing.Context
 9836             {
 9837                 public Context() : context(), value(), fromMDBool(), fromMDLong(), fromMDString(), fromMDStructRef()
 9838                 {
 9839                 }
 9840                 public cmsx.intermediate.Context* context;
 9841                 public MDItem* value;
 9842                 public MDBool* fromMDBool;
 9843                 public MDLong* fromMDLong;
 9844                 public MDString* fromMDString;
 9845                 public MDStructRef* fromMDStructRef;
 9846             }
 9847         }
 9848 
 9849         public class MDBoolRule : System.Text.Parsing.RuleParser
 9850         {
 9851             public MDBoolRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9852             {
 9853                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9854                 SetValueTypeName(ToUtf32("MDBool*"));
 9855             }
 9856             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9857             {
 9858                 parsingData->PushContext(Id(), new Context());
 9859                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9860                 UniquePtr<Object> context_value = stack.Pop();
 9861                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9862             }
 9863             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9864             {
 9865                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9866                 if (matched)
 9867                 {
 9868                     stack.Push(UniquePtr<Object>(new ValueObject<MDBool*>(context->value)));
 9869                 }
 9870                 parsingData->PopContext(Id());
 9871             }
 9872             public override void Link()
 9873             {
 9874                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9875                 a0ActionParser->SetAction(A0Action);
 9876                 ActionParser* a1ActionParser = GetAction(ToUtf32("A1"));
 9877                 a1ActionParser->SetAction(A1Action);
 9878             }
 9879             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9880             {
 9881                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9882                 context->value = context->context->CreateMDBool(true);
 9883             }
 9884             public void A1Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9885             {
 9886                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9887                 context->value = context->context->CreateMDBool(false);
 9888             }
 9889             public class Context : System.Text.Parsing.Context
 9890             {
 9891                 public Context() : context(), value()
 9892                 {
 9893                 }
 9894                 public cmsx.intermediate.Context* context;
 9895                 public MDBool* value;
 9896             }
 9897         }
 9898 
 9899         public class MDLongRule : System.Text.Parsing.RuleParser
 9900         {
 9901             public MDLongRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9902             {
 9903                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9904                 SetValueTypeName(ToUtf32("MDLong*"));
 9905             }
 9906             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9907             {
 9908                 parsingData->PushContext(Id(), new Context());
 9909                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9910                 UniquePtr<Object> context_value = stack.Pop();
 9911                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9912             }
 9913             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9914             {
 9915                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9916                 if (matched)
 9917                 {
 9918                     stack.Push(UniquePtr<Object>(new ValueObject<MDLong*>(context->value)));
 9919                 }
 9920                 parsingData->PopContext(Id());
 9921             }
 9922             public override void Link()
 9923             {
 9924                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9925                 a0ActionParser->SetAction(A0Action);
 9926                 NonterminalParser* xNonterminalParser = GetNonterminal(ToUtf32("x"));
 9927                 xNonterminalParser->SetPost(Postx);
 9928             }
 9929             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9930             {
 9931                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9932                 context->value = context->context->CreateMDLong(context->fromx);
 9933             }
 9934             public void Postx(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9935             {
 9936                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9937                 if (matched)
 9938                 {
 9939                     UniquePtr<Object> fromx_value = stack.Pop();
 9940                     context->fromx = *cast<ValueObject<long>*>(fromx_value.Get());
 9941                 }
 9942             }
 9943             public class Context : System.Text.Parsing.Context
 9944             {
 9945                 public Context() : context(), value(), fromx()
 9946                 {
 9947                 }
 9948                 public cmsx.intermediate.Context* context;
 9949                 public MDLong* value;
 9950                 public long fromx;
 9951             }
 9952         }
 9953 
 9954         public class MDStringRule : System.Text.Parsing.RuleParser
 9955         {
 9956             public MDStringRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
 9957             {
 9958                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
 9959                 SetValueTypeName(ToUtf32("MDString*"));
 9960             }
 9961             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
 9962             {
 9963                 parsingData->PushContext(Id(), new Context());
 9964                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9965                 UniquePtr<Object> context_value = stack.Pop();
 9966                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
 9967             }
 9968             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9969             {
 9970                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9971                 if (matched)
 9972                 {
 9973                     stack.Push(UniquePtr<Object>(new ValueObject<MDString*>(context->value)));
 9974                 }
 9975                 parsingData->PopContext(Id());
 9976             }
 9977             public override void Link()
 9978             {
 9979                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
 9980                 a0ActionParser->SetAction(A0Action);
 9981                 NonterminalParser* sNonterminalParser = GetNonterminal(ToUtf32("s"));
 9982                 sNonterminalParser->SetPost(Posts);
 9983             }
 9984             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
 9985             {
 9986                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9987                 context->value = context->context->CreateMDString(ToUtf8(context->froms));
 9988             }
 9989             public void Posts(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
 9990             {
 9991                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
 9992                 if (matched)
 9993                 {
 9994                     UniquePtr<Object> froms_value = stack.Pop();
 9995                     context->froms = *cast<ValueObject<ustring>*>(froms_value.Get());
 9996                 }
 9997             }
 9998             public class Context : System.Text.Parsing.Context
 9999             {
10000                 public Context() : context(), value(), froms()
10001                 {
10002                 }
10003                 public cmsx.intermediate.Context* context;
10004                 public MDString* value;
10005                 public ustring froms;
10006             }
10007         }
10008 
10009         public class MDStructRefRule : System.Text.Parsing.RuleParser
10010         {
10011             public MDStructRefRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
10012             {
10013                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
10014                 SetValueTypeName(ToUtf32("MDStructRef*"));
10015             }
10016             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
10017             {
10018                 parsingData->PushContext(Id(), new Context());
10019                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10020                 UniquePtr<Object> context_value = stack.Pop();
10021                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
10022             }
10023             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10024             {
10025                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10026                 if (matched)
10027                 {
10028                     stack.Push(UniquePtr<Object>(new ValueObject<MDStructRef*>(context->value)));
10029                 }
10030                 parsingData->PopContext(Id());
10031             }
10032             public override void Link()
10033             {
10034                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
10035                 a0ActionParser->SetAction(A0Action);
10036                 NonterminalParser* idNonterminalParser = GetNonterminal(ToUtf32("id"));
10037                 idNonterminalParser->SetPost(Postid);
10038             }
10039             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
10040             {
10041                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10042                 context->value = context->context->CreateMDStructRef(context->fromid);
10043             }
10044             public void Postid(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10045             {
10046                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10047                 if (matched)
10048                 {
10049                     UniquePtr<Object> fromid_value = stack.Pop();
10050                     context->fromid = *cast<ValueObject<int>*>(fromid_value.Get());
10051                 }
10052             }
10053             public class Context : System.Text.Parsing.Context
10054             {
10055                 public Context() : context(), value(), fromid()
10056                 {
10057                 }
10058                 public cmsx.intermediate.Context* context;
10059                 public MDStructRef* value;
10060                 public int fromid;
10061             }
10062         }
10063 
10064         public class MDStructRule : System.Text.Parsing.RuleParser
10065         {
10066             public MDStructRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
10067             {
10068                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
10069                 SetValueTypeName(ToUtf32("MDStruct*"));
10070             }
10071             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
10072             {
10073                 parsingData->PushContext(Id(), new Context());
10074                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10075                 UniquePtr<Object> context_value = stack.Pop();
10076                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
10077             }
10078             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10079             {
10080                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10081                 if (matched)
10082                 {
10083                     stack.Push(UniquePtr<Object>(new ValueObject<MDStruct*>(context->value)));
10084                 }
10085                 parsingData->PopContext(Id());
10086             }
10087             public override void Link()
10088             {
10089                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
10090                 a0ActionParser->SetAction(A0Action);
10091                 NonterminalParser* idNonterminalParser = GetNonterminal(ToUtf32("id"));
10092                 idNonterminalParser->SetPost(Postid);
10093                 NonterminalParser* fieldNonterminalParser = GetNonterminal(ToUtf32("field"));
10094                 fieldNonterminalParser->SetPre(Prefield);
10095             }
10096             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
10097             {
10098                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10099                 context->value = context->context->CreateMDStruct(context->fromid);
10100             }
10101             public void Postid(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10102             {
10103                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10104                 if (matched)
10105                 {
10106                     UniquePtr<Object> fromid_value = stack.Pop();
10107                     context->fromid = *cast<ValueObject<int>*>(fromid_value.Get());
10108                 }
10109             }
10110             public void Prefield(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
10111             {
10112                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10113                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
10114                 stack.Push(UniquePtr<Object>(new ValueObject<MDStruct*>(context->value)));
10115             }
10116             public class Context : System.Text.Parsing.Context
10117             {
10118                 public Context() : context(), value(), fromid()
10119                 {
10120                 }
10121                 public cmsx.intermediate.Context* context;
10122                 public MDStruct* value;
10123                 public int fromid;
10124             }
10125         }
10126 
10127         public class MDFieldRule : System.Text.Parsing.RuleParser
10128         {
10129             public MDFieldRule(const ustring& name_, Scope* enclosingScope_, int id_, Parser* definition_) : base(name_, enclosingScope_, id_, definition_)
10130             {
10131                 AddInheritedAttribute(AttrOrVar(ToUtf32("cmsx.intermediate.Context*"), ToUtf32("context")));
10132                 AddInheritedAttribute(AttrOrVar(ToUtf32("MDStruct*"), ToUtf32("parent")));
10133             }
10134             public override void Enter(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
10135             {
10136                 parsingData->PushContext(Id(), new Context());
10137                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10138                 UniquePtr<Object> parent_value = stack.Pop();
10139                 context->parent = *cast<ValueObject<MDStruct*>*>(parent_value.Get());
10140                 UniquePtr<Object> context_value = stack.Pop();
10141                 context->context = *cast<ValueObject<cmsx.intermediate.Context*>*>(context_value.Get());
10142             }
10143             public override void Leave(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10144             {
10145                 parsingData->PopContext(Id());
10146             }
10147             public override void Link()
10148             {
10149                 ActionParser* a0ActionParser = GetAction(ToUtf32("A0"));
10150                 a0ActionParser->SetAction(A0Action);
10151                 NonterminalParser* fieldNameNonterminalParser = GetNonterminal(ToUtf32("fieldName"));
10152                 fieldNameNonterminalParser->SetPost(PostfieldName);
10153                 NonterminalParser* itemNonterminalParser = GetNonterminal(ToUtf32("item"));
10154                 itemNonterminalParser->SetPre(Preitem);
10155                 itemNonterminalParser->SetPost(Postitem);
10156             }
10157             public void A0Action(const uchar* matchBegin, const uchar* matchEnd, const Span& span, const string& fileName, ParsingData* parsingData, bool& pass)
10158             {
10159                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10160                 context->parent->AddItem(ToUtf8(context->fromfieldName), context->fromitem);
10161             }
10162             public void PostfieldName(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10163             {
10164                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10165                 if (matched)
10166                 {
10167                     UniquePtr<Object> fromfieldName_value = stack.Pop();
10168                     context->fromfieldName = *cast<ValueObject<ustring>*>(fromfieldName_value.Get());
10169                 }
10170             }
10171             public void Preitem(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData)
10172             {
10173                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10174                 stack.Push(UniquePtr<Object>(new ValueObject<cmsx.intermediate.Context*>(context->context)));
10175             }
10176             public void Postitem(Stack<UniquePtr<Object>>& stack, ParsingData* parsingData, bool matched)
10177             {
10178                 Context* context = cast<Context*>(parsingData->GetContext(Id()));
10179                 if (matched)
10180                 {
10181                     UniquePtr<Object> fromitem_value = stack.Pop();
10182                     context->fromitem = *cast<ValueObject<MDItem*>*>(fromitem_value.Get());
10183                 }
10184             }
10185             public class Context : System.Text.Parsing.Context
10186             {
10187                 public Context() : context(), parent(), fromfieldName(), fromitem()
10188                 {
10189                 }
10190                 public cmsx.intermediate.Context* context;
10191                 public MDStruct* parent;
10192                 public ustring fromfieldName;
10193                 public MDItem* fromitem;
10194             }
10195         }
10196 
10197         public override void GetReferencedGrammars()
10198         {
10199             ParsingDomain* pd = Domain();
10200             Grammar* grammar0 = pd->GetGrammar(ToUtf32("System.Text.Parsing.stdlib"));
10201             if (grammar0 == null)
10202             {
10203                 grammar0 = new System.Text.Parsing.stdlib(pd);
10204             }
10205             AddGrammarReference(grammar0);
10206         }
10207         public override void CreateRules()
10208         {
10209             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("identifier"), this, ToUtf32("System.Text.Parsing.stdlib.identifier")));
10210             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("newline"), this, ToUtf32("System.Text.Parsing.stdlib.newline")));
10211             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("bool"), this, ToUtf32("System.Text.Parsing.stdlib.bool")));
10212             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("sbyte"), this, ToUtf32("System.Text.Parsing.stdlib.sbyte")));
10213             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("byte"), this, ToUtf32("System.Text.Parsing.stdlib.byte")));
10214             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("short"), this, ToUtf32("System.Text.Parsing.stdlib.short")));
10215             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ushort"), this, ToUtf32("System.Text.Parsing.stdlib.ushort")));
10216             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("int"), this, ToUtf32("System.Text.Parsing.stdlib.int")));
10217             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("uint"), this, ToUtf32("System.Text.Parsing.stdlib.uint")));
10218             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("long"), this, ToUtf32("System.Text.Parsing.stdlib.long")));
10219             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("ulong"), this, ToUtf32("System.Text.Parsing.stdlib.ulong")));
10220             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("float"), this, ToUtf32("System.Text.Parsing.stdlib.float")));
10221             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("double"), this, ToUtf32("System.Text.Parsing.stdlib.double")));
10222             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("string"), this, ToUtf32("System.Text.Parsing.stdlib.string")));
10223             AddRuleLink(new System.Text.Parsing.RuleLink(ToUtf32("spaces"), this, ToUtf32("System.Text.Parsing.stdlib.spaces")));
10224             AddRule(new IntermediateCodeFileRule(ToUtf32("IntermediateCodeFile"), GetScope(), Domain()->GetNextRuleId(), 
10225                 new System.Text.Parsing.SequenceParser(
10226                     new System.Text.Parsing.SequenceParser(
10227                         new System.Text.Parsing.SequenceParser(
10228                             new System.Text.Parsing.SequenceParser(
10229                                 new System.Text.Parsing.SequenceParser(
10230                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10231                                         new System.Text.Parsing.EmptyParser()), 
10232                                     new System.Text.Parsing.NonterminalParser(ToUtf32("CompileUnitHeader"), ToUtf32("CompileUnitHeader"), 1)), 
10233                                 new System.Text.Parsing.OptionalParser(
10234                                     new System.Text.Parsing.NonterminalParser(ToUtf32("TypeDeclarations"), ToUtf32("TypeDeclarations"), 1))), 
10235                             new System.Text.Parsing.OptionalParser(
10236                                 new System.Text.Parsing.NonterminalParser(ToUtf32("DataDefinitions"), ToUtf32("DataDefinitions"), 1))), 
10237                         new System.Text.Parsing.OptionalParser(
10238                             new System.Text.Parsing.NonterminalParser(ToUtf32("Functions"), ToUtf32("Functions"), 1))), 
10239                     new System.Text.Parsing.OptionalParser(
10240                         new System.Text.Parsing.NonterminalParser(ToUtf32("Metadata"), ToUtf32("Metadata"), 1)))));
10241             AddRule(new CompileUnitHeaderRule(ToUtf32("CompileUnitHeader"), GetScope(), Domain()->GetNextRuleId(), 
10242                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10243                     new System.Text.Parsing.GroupingParser(
10244                         new System.Text.Parsing.SequenceParser(
10245                             new System.Text.Parsing.SequenceParser(
10246                                 new System.Text.Parsing.SequenceParser(
10247                                     new System.Text.Parsing.SequenceParser(
10248                                         new System.Text.Parsing.SequenceParser(
10249                                             new System.Text.Parsing.KeywordParser(ToUtf32("cu")), 
10250                                             new System.Text.Parsing.CharParser('(')), 
10251                                         new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
10252                                             new System.Text.Parsing.GroupingParser(
10253                                                 new System.Text.Parsing.PositiveParser(
10254                                                     new System.Text.Parsing.HexDigitParser())))), 
10255                                     new System.Text.Parsing.CharParser(',')), 
10256                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
10257                                     new System.Text.Parsing.NonterminalParser(ToUtf32("MDStructRef"), ToUtf32("MDStructRef"), 1))), 
10258                             new System.Text.Parsing.CharParser(')'))))));
10259             AddRule(new TypeDeclarationsRule(ToUtf32("TypeDeclarations"), GetScope(), Domain()->GetNextRuleId(), 
10260                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10261                     new System.Text.Parsing.GroupingParser(
10262                         new System.Text.Parsing.SequenceParser(
10263                             new System.Text.Parsing.SequenceParser(
10264                                 new System.Text.Parsing.SequenceParser(
10265                                     new System.Text.Parsing.KeywordParser(ToUtf32("types")), 
10266                                     new System.Text.Parsing.ExpectationParser(
10267                                         new System.Text.Parsing.CharParser('{'))), 
10268                                 new System.Text.Parsing.KleeneStarParser(
10269                                     new System.Text.Parsing.NonterminalParser(ToUtf32("TypeDeclaration"), ToUtf32("TypeDeclaration"), 1))), 
10270                             new System.Text.Parsing.ExpectationParser(
10271                                 new System.Text.Parsing.CharParser('}')))))));
10272             AddRule(new DataDefinitionsRule(ToUtf32("DataDefinitions"), GetScope(), Domain()->GetNextRuleId(), 
10273                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10274                     new System.Text.Parsing.GroupingParser(
10275                         new System.Text.Parsing.SequenceParser(
10276                             new System.Text.Parsing.SequenceParser(
10277                                 new System.Text.Parsing.SequenceParser(
10278                                     new System.Text.Parsing.KeywordParser(ToUtf32("data")), 
10279                                     new System.Text.Parsing.ExpectationParser(
10280                                         new System.Text.Parsing.CharParser('{'))), 
10281                                 new System.Text.Parsing.KleeneStarParser(
10282                                     new System.Text.Parsing.NonterminalParser(ToUtf32("DataDefinition"), ToUtf32("DataDefinition"), 1))), 
10283                             new System.Text.Parsing.ExpectationParser(
10284                                 new System.Text.Parsing.CharParser('}')))))));
10285             AddRule(new FunctionsRule(ToUtf32("Functions"), GetScope(), Domain()->GetNextRuleId(), 
10286                 new System.Text.Parsing.KleeneStarParser(
10287                     new System.Text.Parsing.NonterminalParser(ToUtf32("Function"), ToUtf32("Function"), 1))));
10288             AddRule(new FunctionRule(ToUtf32("Function"), GetScope(), Domain()->GetNextRuleId(), 
10289                 new System.Text.Parsing.SequenceParser(
10290                     new System.Text.Parsing.SequenceParser(
10291                         new System.Text.Parsing.SequenceParser(
10292                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10293                                 new System.Text.Parsing.NonterminalParser(ToUtf32("function"), ToUtf32("FunctionHeader"), 1)), 
10294                             new System.Text.Parsing.ExpectationParser(
10295                                 new System.Text.Parsing.CharParser('{'))), 
10296                         new System.Text.Parsing.KleeneStarParser(
10297                             new System.Text.Parsing.NonterminalParser(ToUtf32("BasicBlock"), ToUtf32("BasicBlock"), 2))), 
10298                     new System.Text.Parsing.ExpectationParser(
10299                         new System.Text.Parsing.CharParser('}')))));
10300             AddRule(new FunctionHeaderRule(ToUtf32("FunctionHeader"), GetScope(), Domain()->GetNextRuleId(), 
10301                 new System.Text.Parsing.SequenceParser(
10302                     new System.Text.Parsing.SequenceParser(
10303                         new System.Text.Parsing.SequenceParser(
10304                             new System.Text.Parsing.SequenceParser(
10305                                 new System.Text.Parsing.KeywordParser(ToUtf32("function")), 
10306                                 new System.Text.Parsing.ExpectationParser(
10307                                     new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))), 
10308                             new System.Text.Parsing.OptionalParser(
10309                                 new System.Text.Parsing.GroupingParser(
10310                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10311                                         new System.Text.Parsing.KeywordParser(ToUtf32("once")))))), 
10312                         new System.Text.Parsing.ExpectationParser(
10313                             new System.Text.Parsing.NonterminalParser(ToUtf32("functionId"), ToUtf32("identifier"), 0))), 
10314                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
10315                         new System.Text.Parsing.GroupingParser(
10316                             new System.Text.Parsing.OptionalParser(
10317                                 new System.Text.Parsing.NonterminalParser(ToUtf32("md"), ToUtf32("MDStructRef"), 1)))))));
10318             AddRule(new BasicBlockRule(ToUtf32("BasicBlock"), GetScope(), Domain()->GetNextRuleId(), 
10319                 new System.Text.Parsing.TokenParser(
10320                     new System.Text.Parsing.SequenceParser(
10321                         new System.Text.Parsing.SequenceParser(
10322                             new System.Text.Parsing.SequenceParser(
10323                                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10324                                     new System.Text.Parsing.NonterminalParser(ToUtf32("id"), ToUtf32("Label"), 0)), 
10325                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10326                             new System.Text.Parsing.PositiveParser(
10327                                 new System.Text.Parsing.NonterminalParser(ToUtf32("InstructionLine"), ToUtf32("InstructionLine"), 2))), 
10328                         new System.Text.Parsing.OptionalParser(
10329                             new System.Text.Parsing.NonterminalParser(ToUtf32("EmptyLine"), ToUtf32("EmptyLine"), 0))))));
10330             AddRule(new System.Text.Parsing.RuleParser(ToUtf32("EmptyLine"), GetScope(), Domain()->GetNextRuleId(), 
10331                 new System.Text.Parsing.TokenParser(
10332                     new System.Text.Parsing.SequenceParser(
10333                         new System.Text.Parsing.OptionalParser(
10334                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10335                         new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0)))));
10336             AddRule(new InstructionLineRule(ToUtf32("InstructionLine"), GetScope(), Domain()->GetNextRuleId(), 
10337                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10338                     new System.Text.Parsing.TokenParser(
10339                         new System.Text.Parsing.SequenceParser(
10340                             new System.Text.Parsing.SequenceParser(
10341                                 new System.Text.Parsing.SequenceParser(
10342                                     new System.Text.Parsing.SequenceParser(
10343                                         new System.Text.Parsing.OptionalParser(
10344                                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10345                                         new System.Text.Parsing.NonterminalParser(ToUtf32("Instruction"), ToUtf32("Instruction"), 1)), 
10346                                     new System.Text.Parsing.OptionalParser(
10347                                         new System.Text.Parsing.GroupingParser(
10348                                             new System.Text.Parsing.SequenceParser(
10349                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0), 
10350                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("lineInfo"), ToUtf32("MDStructRef"), 1))))), 
10351                                 new System.Text.Parsing.OptionalParser(
10352                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))), 
10353                             new System.Text.Parsing.ExpectationParser(
10354                                 new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0)))))));
10355             AddRule(new InstructionRule(ToUtf32("Instruction"), GetScope(), Domain()->GetNextRuleId(), 
10356                 new System.Text.Parsing.AlternativeParser(
10357                     new System.Text.Parsing.AlternativeParser(
10358                         new System.Text.Parsing.AlternativeParser(
10359                             new System.Text.Parsing.AlternativeParser(
10360                                 new System.Text.Parsing.AlternativeParser(
10361                                     new System.Text.Parsing.AlternativeParser(
10362                                         new System.Text.Parsing.AlternativeParser(
10363                                             new System.Text.Parsing.AlternativeParser(
10364                                                 new System.Text.Parsing.AlternativeParser(
10365                                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10366                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("StoreInstruction"), ToUtf32("StoreInstruction"), 1)), 
10367                                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
10368                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ArgInstruction"), ToUtf32("ArgInstruction"), 1))), 
10369                                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
10370                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("JumpInstruction"), ToUtf32("JumpInstruction"), 1))), 
10371                                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
10372                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("BranchInstruction"), ToUtf32("BranchInstruction"), 1))), 
10373                                         new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
10374                                             new System.Text.Parsing.NonterminalParser(ToUtf32("ProcedureCallInstruction"), ToUtf32("ProcedureCallInstruction"), 1))), 
10375                                     new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
10376                                         new System.Text.Parsing.NonterminalParser(ToUtf32("RetInstruction"), ToUtf32("RetInstruction"), 1))), 
10377                                 new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
10378                                     new System.Text.Parsing.NonterminalParser(ToUtf32("SwitchInstruction"), ToUtf32("SwitchInstruction"), 1))), 
10379                             new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
10380                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ValueInstruction"), ToUtf32("ValueInstruction"), 1))), 
10381                         new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
10382                             new System.Text.Parsing.NonterminalParser(ToUtf32("NoOperationInstruction"), ToUtf32("NoOperationInstruction"), 1))), 
10383                     new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
10384                         new System.Text.Parsing.NonterminalParser(ToUtf32("SaveInstruction"), ToUtf32("SaveInstruction"), 1)))));
10385             AddRule(new StoreInstructionRule(ToUtf32("StoreInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10386                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10387                     new System.Text.Parsing.GroupingParser(
10388                         new System.Text.Parsing.SequenceParser(
10389                             new System.Text.Parsing.SequenceParser(
10390                                 new System.Text.Parsing.SequenceParser(
10391                                     new System.Text.Parsing.SequenceParser(
10392                                         new System.Text.Parsing.SequenceParser(
10393                                             new System.Text.Parsing.SequenceParser(
10394                                                 new System.Text.Parsing.SequenceParser(
10395                                                     new System.Text.Parsing.SequenceParser(
10396                                                         new System.Text.Parsing.KeywordParser(ToUtf32("store")), 
10397                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10398                                                     new System.Text.Parsing.ExpectationParser(
10399                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))), 
10400                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10401                                             new System.Text.Parsing.ExpectationParser(
10402                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2))), 
10403                                         new System.Text.Parsing.ExpectationParser(
10404                                             new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10405                                     new System.Text.Parsing.ExpectationParser(
10406                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ptrType"), ToUtf32("TypeExpr"), 1))), 
10407                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10408                             new System.Text.Parsing.ExpectationParser(
10409                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Value"), 2)))))));
10410             AddRule(new ArgInstructionRule(ToUtf32("ArgInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10411                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10412                     new System.Text.Parsing.GroupingParser(
10413                         new System.Text.Parsing.SequenceParser(
10414                             new System.Text.Parsing.SequenceParser(
10415                                 new System.Text.Parsing.SequenceParser(
10416                                     new System.Text.Parsing.SequenceParser(
10417                                         new System.Text.Parsing.KeywordParser(ToUtf32("arg")), 
10418                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10419                                     new System.Text.Parsing.ExpectationParser(
10420                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))), 
10421                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10422                             new System.Text.Parsing.ExpectationParser(
10423                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Value"), 2)))))));
10424             AddRule(new JumpInstructionRule(ToUtf32("JumpInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10425                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10426                     new System.Text.Parsing.GroupingParser(
10427                         new System.Text.Parsing.SequenceParser(
10428                             new System.Text.Parsing.SequenceParser(
10429                                 new System.Text.Parsing.KeywordParser(ToUtf32("jmp")), 
10430                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10431                             new System.Text.Parsing.ExpectationParser(
10432                                 new System.Text.Parsing.NonterminalParser(ToUtf32("target"), ToUtf32("Label"), 0)))))));
10433             AddRule(new BranchInstructionRule(ToUtf32("BranchInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10434                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10435                     new System.Text.Parsing.GroupingParser(
10436                         new System.Text.Parsing.SequenceParser(
10437                             new System.Text.Parsing.SequenceParser(
10438                                 new System.Text.Parsing.SequenceParser(
10439                                     new System.Text.Parsing.SequenceParser(
10440                                         new System.Text.Parsing.SequenceParser(
10441                                             new System.Text.Parsing.SequenceParser(
10442                                                 new System.Text.Parsing.SequenceParser(
10443                                                     new System.Text.Parsing.SequenceParser(
10444                                                         new System.Text.Parsing.KeywordParser(ToUtf32("branch")), 
10445                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10446                                                     new System.Text.Parsing.ExpectationParser(
10447                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))), 
10448                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10449                                             new System.Text.Parsing.ExpectationParser(
10450                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("cond"), ToUtf32("Value"), 2))), 
10451                                         new System.Text.Parsing.ExpectationParser(
10452                                             new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10453                                     new System.Text.Parsing.ExpectationParser(
10454                                         new System.Text.Parsing.NonterminalParser(ToUtf32("trueTarget"), ToUtf32("Label"), 0))), 
10455                                 new System.Text.Parsing.ExpectationParser(
10456                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10457                             new System.Text.Parsing.ExpectationParser(
10458                                 new System.Text.Parsing.NonterminalParser(ToUtf32("falseTarget"), ToUtf32("Label"), 0)))))));
10459             AddRule(new ProcedureCallInstructionRule(ToUtf32("ProcedureCallInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10460                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10461                     new System.Text.Parsing.GroupingParser(
10462                         new System.Text.Parsing.SequenceParser(
10463                             new System.Text.Parsing.SequenceParser(
10464                                 new System.Text.Parsing.SequenceParser(
10465                                     new System.Text.Parsing.SequenceParser(
10466                                         new System.Text.Parsing.KeywordParser(ToUtf32("call")), 
10467                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10468                                     new System.Text.Parsing.ExpectationParser(
10469                                         new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))), 
10470                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10471                             new System.Text.Parsing.ExpectationParser(
10472                                 new System.Text.Parsing.NonterminalParser(ToUtf32("callee"), ToUtf32("Value"), 2)))))));
10473             AddRule(new RetInstructionRule(ToUtf32("RetInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10474                 new System.Text.Parsing.SequenceParser(
10475                     new System.Text.Parsing.SequenceParser(
10476                         new System.Text.Parsing.KeywordParser(ToUtf32("ret")), 
10477                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10478                     new System.Text.Parsing.GroupingParser(
10479                         new System.Text.Parsing.AlternativeParser(
10480                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10481                                 new System.Text.Parsing.GroupingParser(
10482                                     new System.Text.Parsing.DifferenceParser(
10483                                         new System.Text.Parsing.KeywordParser(ToUtf32("void")), 
10484                                         new System.Text.Parsing.StringParser(ToUtf32("void*"))))), 
10485                             new System.Text.Parsing.SequenceParser(
10486                                 new System.Text.Parsing.SequenceParser(
10487                                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1), 
10488                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10489                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
10490                                     new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2))))))));
10491             AddRule(new SwitchInstructionRule(ToUtf32("SwitchInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10492                 new System.Text.Parsing.SequenceParser(
10493                     new System.Text.Parsing.SequenceParser(
10494                         new System.Text.Parsing.SequenceParser(
10495                             new System.Text.Parsing.SequenceParser(
10496                                 new System.Text.Parsing.SequenceParser(
10497                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10498                                         new System.Text.Parsing.GroupingParser(
10499                                             new System.Text.Parsing.SequenceParser(
10500                                                 new System.Text.Parsing.SequenceParser(
10501                                                     new System.Text.Parsing.SequenceParser(
10502                                                         new System.Text.Parsing.SequenceParser(
10503                                                             new System.Text.Parsing.SequenceParser(
10504                                                                 new System.Text.Parsing.SequenceParser(
10505                                                                     new System.Text.Parsing.KeywordParser(ToUtf32("switch")), 
10506                                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10507                                                                 new System.Text.Parsing.ExpectationParser(
10508                                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1))), 
10509                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10510                                                         new System.Text.Parsing.ExpectationParser(
10511                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("cond"), ToUtf32("Value"), 2))), 
10512                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10513                                                 new System.Text.Parsing.ExpectationParser(
10514                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("defaultTarget"), ToUtf32("Label"), 0))))), 
10515                                     new System.Text.Parsing.ExpectationParser(
10516                                         new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10517                                 new System.Text.Parsing.ExpectationParser(
10518                                     new System.Text.Parsing.CharParser('['))), 
10519                             new System.Text.Parsing.OptionalParser(
10520                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))), 
10521                         new System.Text.Parsing.ListParser(
10522                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
10523                                 new System.Text.Parsing.GroupingParser(
10524                                     new System.Text.Parsing.SequenceParser(
10525                                         new System.Text.Parsing.SequenceParser(
10526                                             new System.Text.Parsing.SequenceParser(
10527                                                 new System.Text.Parsing.SequenceParser(
10528                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("caseType"), ToUtf32("TypeExpr"), 1), 
10529                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10530                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("caseValue"), ToUtf32("Value"), 2)), 
10531                                             new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0)), 
10532                                         new System.Text.Parsing.NonterminalParser(ToUtf32("caseTarget"), ToUtf32("Label"), 0)))), 
10533                             new System.Text.Parsing.GroupingParser(
10534                                 new System.Text.Parsing.SequenceParser(
10535                                     new System.Text.Parsing.SequenceParser(
10536                                         new System.Text.Parsing.OptionalParser(
10537                                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10538                                         new System.Text.Parsing.CharParser(':')), 
10539                                     new System.Text.Parsing.OptionalParser(
10540                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)))))), 
10541                     new System.Text.Parsing.ExpectationParser(
10542                         new System.Text.Parsing.CharParser(']')))));
10543             AddRule(new NoOperationInstructionRule(ToUtf32("NoOperationInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10544                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10545                     new System.Text.Parsing.KeywordParser(ToUtf32("nop")))));
10546             AddRule(new SaveInstructionRule(ToUtf32("SaveInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10547                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10548                     new System.Text.Parsing.KeywordParser(ToUtf32("save")))));
10549             AddRule(new ValueInstructionRule(ToUtf32("ValueInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10550                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10551                     new System.Text.Parsing.GroupingParser(
10552                         new System.Text.Parsing.SequenceParser(
10553                             new System.Text.Parsing.SequenceParser(
10554                                 new System.Text.Parsing.SequenceParser(
10555                                     new System.Text.Parsing.SequenceParser(
10556                                         new System.Text.Parsing.SequenceParser(
10557                                             new System.Text.Parsing.SequenceParser(
10558                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1), 
10559                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10560                                             new System.Text.Parsing.ExpectationParser(
10561                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("result"), ToUtf32("Value"), 2))), 
10562                                         new System.Text.Parsing.OptionalParser(
10563                                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))), 
10564                                     new System.Text.Parsing.CharParser('=')), 
10565                                 new System.Text.Parsing.OptionalParser(
10566                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0))), 
10567                             new System.Text.Parsing.ExpectationParser(
10568                                 new System.Text.Parsing.NonterminalParser(ToUtf32("Operation"), ToUtf32("Operation"), 2)))))));
10569             AddRule(new OperationRule(ToUtf32("Operation"), GetScope(), Domain()->GetNextRuleId(), 
10570                 new System.Text.Parsing.AlternativeParser(
10571                     new System.Text.Parsing.AlternativeParser(
10572                         new System.Text.Parsing.AlternativeParser(
10573                             new System.Text.Parsing.AlternativeParser(
10574                                 new System.Text.Parsing.AlternativeParser(
10575                                     new System.Text.Parsing.AlternativeParser(
10576                                         new System.Text.Parsing.AlternativeParser(
10577                                             new System.Text.Parsing.AlternativeParser(
10578                                                 new System.Text.Parsing.AlternativeParser(
10579                                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10580                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("UnaryInstruction"), ToUtf32("UnaryInstruction"), 2)), 
10581                                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
10582                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("BinaryInstruction"), ToUtf32("BinaryInstruction"), 2))), 
10583                                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
10584                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ParamInstruction"), ToUtf32("ParamInstruction"), 2))), 
10585                                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
10586                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("LocalInstruction"), ToUtf32("LocalInstruction"), 2))), 
10587                                         new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
10588                                             new System.Text.Parsing.NonterminalParser(ToUtf32("LoadInstruction"), ToUtf32("LoadInstruction"), 2))), 
10589                                     new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
10590                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ElemAddrInstruction"), ToUtf32("ElemAddrInstruction"), 2))), 
10591                                 new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
10592                                     new System.Text.Parsing.NonterminalParser(ToUtf32("PtrOffsetInstruction"), ToUtf32("PtrOffsetInstruction"), 2))), 
10593                             new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
10594                                 new System.Text.Parsing.NonterminalParser(ToUtf32("PtrDiffInstruction"), ToUtf32("PtrDiffInstruction"), 2))), 
10595                         new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
10596                             new System.Text.Parsing.NonterminalParser(ToUtf32("FunctionCallInstruction"), ToUtf32("FunctionCallInstruction"), 2))), 
10597                     new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
10598                         new System.Text.Parsing.NonterminalParser(ToUtf32("TrapInstruction"), ToUtf32("TrapInstruction"), 2)))));
10599             AddRule(new UnaryInstructionRule(ToUtf32("UnaryInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10600                 new System.Text.Parsing.AlternativeParser(
10601                     new System.Text.Parsing.AlternativeParser(
10602                         new System.Text.Parsing.AlternativeParser(
10603                             new System.Text.Parsing.AlternativeParser(
10604                                 new System.Text.Parsing.AlternativeParser(
10605                                     new System.Text.Parsing.AlternativeParser(
10606                                         new System.Text.Parsing.AlternativeParser(
10607                                             new System.Text.Parsing.AlternativeParser(
10608                                                 new System.Text.Parsing.AlternativeParser(
10609                                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10610                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("NotInstruction"), ToUtf32("NotInstruction"), 2)), 
10611                                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
10612                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("NegInstruction"), ToUtf32("NegInstruction"), 2))), 
10613                                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
10614                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("SignExtendInstruction"), ToUtf32("SignExtendInstruction"), 2))), 
10615                                             new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
10616                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ZeroExtendInstruction"), ToUtf32("ZeroExtendInstruction"), 2))), 
10617                                         new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
10618                                             new System.Text.Parsing.NonterminalParser(ToUtf32("TruncateInstruction"), ToUtf32("TruncateInstruction"), 2))), 
10619                                     new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
10620                                         new System.Text.Parsing.NonterminalParser(ToUtf32("BitCastInstruction"), ToUtf32("BitCastInstruction"), 2))), 
10621                                 new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
10622                                     new System.Text.Parsing.NonterminalParser(ToUtf32("IntToFloatInstruction"), ToUtf32("IntToFloatInstruction"), 2))), 
10623                             new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
10624                                 new System.Text.Parsing.NonterminalParser(ToUtf32("FloatToIntInstruction"), ToUtf32("FloatToIntInstruction"), 2))), 
10625                         new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
10626                             new System.Text.Parsing.NonterminalParser(ToUtf32("IntToPtrInstruction"), ToUtf32("IntToPtrInstruction"), 2))), 
10627                     new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
10628                         new System.Text.Parsing.NonterminalParser(ToUtf32("PtrToIntInstruction"), ToUtf32("PtrToIntInstruction"), 2)))));
10629             AddRule(new NotInstructionRule(ToUtf32("NotInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10630                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10631                     new System.Text.Parsing.GroupingParser(
10632                         new System.Text.Parsing.SequenceParser(
10633                             new System.Text.Parsing.SequenceParser(
10634                                 new System.Text.Parsing.KeywordParser(ToUtf32("not")), 
10635                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10636                             new System.Text.Parsing.ExpectationParser(
10637                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10638             AddRule(new NegInstructionRule(ToUtf32("NegInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10639                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10640                     new System.Text.Parsing.GroupingParser(
10641                         new System.Text.Parsing.SequenceParser(
10642                             new System.Text.Parsing.SequenceParser(
10643                                 new System.Text.Parsing.KeywordParser(ToUtf32("neg")), 
10644                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10645                             new System.Text.Parsing.ExpectationParser(
10646                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10647             AddRule(new SignExtendInstructionRule(ToUtf32("SignExtendInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10648                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10649                     new System.Text.Parsing.GroupingParser(
10650                         new System.Text.Parsing.SequenceParser(
10651                             new System.Text.Parsing.SequenceParser(
10652                                 new System.Text.Parsing.KeywordParser(ToUtf32("signextend")), 
10653                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10654                             new System.Text.Parsing.ExpectationParser(
10655                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10656             AddRule(new ZeroExtendInstructionRule(ToUtf32("ZeroExtendInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10657                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10658                     new System.Text.Parsing.GroupingParser(
10659                         new System.Text.Parsing.SequenceParser(
10660                             new System.Text.Parsing.SequenceParser(
10661                                 new System.Text.Parsing.KeywordParser(ToUtf32("zeroextend")), 
10662                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10663                             new System.Text.Parsing.ExpectationParser(
10664                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10665             AddRule(new TruncateInstructionRule(ToUtf32("TruncateInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10666                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10667                     new System.Text.Parsing.GroupingParser(
10668                         new System.Text.Parsing.SequenceParser(
10669                             new System.Text.Parsing.SequenceParser(
10670                                 new System.Text.Parsing.KeywordParser(ToUtf32("truncate")), 
10671                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10672                             new System.Text.Parsing.ExpectationParser(
10673                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10674             AddRule(new BitCastInstructionRule(ToUtf32("BitCastInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10675                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10676                     new System.Text.Parsing.GroupingParser(
10677                         new System.Text.Parsing.SequenceParser(
10678                             new System.Text.Parsing.SequenceParser(
10679                                 new System.Text.Parsing.KeywordParser(ToUtf32("bitcast")), 
10680                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10681                             new System.Text.Parsing.ExpectationParser(
10682                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10683             AddRule(new IntToFloatInstructionRule(ToUtf32("IntToFloatInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10684                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10685                     new System.Text.Parsing.GroupingParser(
10686                         new System.Text.Parsing.SequenceParser(
10687                             new System.Text.Parsing.SequenceParser(
10688                                 new System.Text.Parsing.KeywordParser(ToUtf32("inttofloat")), 
10689                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10690                             new System.Text.Parsing.ExpectationParser(
10691                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10692             AddRule(new FloatToIntInstructionRule(ToUtf32("FloatToIntInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10693                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10694                     new System.Text.Parsing.GroupingParser(
10695                         new System.Text.Parsing.SequenceParser(
10696                             new System.Text.Parsing.SequenceParser(
10697                                 new System.Text.Parsing.KeywordParser(ToUtf32("floattoint")), 
10698                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10699                             new System.Text.Parsing.ExpectationParser(
10700                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10701             AddRule(new IntToPtrInstructionRule(ToUtf32("IntToPtrInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10702                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10703                     new System.Text.Parsing.GroupingParser(
10704                         new System.Text.Parsing.SequenceParser(
10705                             new System.Text.Parsing.SequenceParser(
10706                                 new System.Text.Parsing.KeywordParser(ToUtf32("inttoptr")), 
10707                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10708                             new System.Text.Parsing.ExpectationParser(
10709                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10710             AddRule(new PtrToIntInstructionRule(ToUtf32("PtrToIntInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10711                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10712                     new System.Text.Parsing.GroupingParser(
10713                         new System.Text.Parsing.SequenceParser(
10714                             new System.Text.Parsing.SequenceParser(
10715                                 new System.Text.Parsing.KeywordParser(ToUtf32("ptrtoint")), 
10716                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10717                             new System.Text.Parsing.ExpectationParser(
10718                                 new System.Text.Parsing.NonterminalParser(ToUtf32("arg"), ToUtf32("Operand"), 1)))))));
10719             AddRule(new BinaryInstructionRule(ToUtf32("BinaryInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10720                 new System.Text.Parsing.AlternativeParser(
10721                     new System.Text.Parsing.AlternativeParser(
10722                         new System.Text.Parsing.AlternativeParser(
10723                             new System.Text.Parsing.AlternativeParser(
10724                                 new System.Text.Parsing.AlternativeParser(
10725                                     new System.Text.Parsing.AlternativeParser(
10726                                         new System.Text.Parsing.AlternativeParser(
10727                                             new System.Text.Parsing.AlternativeParser(
10728                                                 new System.Text.Parsing.AlternativeParser(
10729                                                     new System.Text.Parsing.AlternativeParser(
10730                                                         new System.Text.Parsing.AlternativeParser(
10731                                                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10732                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("AddInstruction"), ToUtf32("AddInstruction"), 2)), 
10733                                                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
10734                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("SubInstruction"), ToUtf32("SubInstruction"), 2))), 
10735                                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
10736                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("MulInstruction"), ToUtf32("MulInstruction"), 2))), 
10737                                                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
10738                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("DivInstruction"), ToUtf32("DivInstruction"), 2))), 
10739                                                 new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
10740                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ModInstruction"), ToUtf32("ModInstruction"), 2))), 
10741                                             new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
10742                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("AndInstruction"), ToUtf32("AndInstruction"), 2))), 
10743                                         new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
10744                                             new System.Text.Parsing.NonterminalParser(ToUtf32("OrInstruction"), ToUtf32("OrInstruction"), 2))), 
10745                                     new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
10746                                         new System.Text.Parsing.NonterminalParser(ToUtf32("XorInstruction"), ToUtf32("XorInstruction"), 2))), 
10747                                 new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
10748                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ShlInstruction"), ToUtf32("ShlInstruction"), 2))), 
10749                             new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
10750                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ShrInstruction"), ToUtf32("ShrInstruction"), 2))), 
10751                         new System.Text.Parsing.ActionParser(ToUtf32("A10"), 
10752                             new System.Text.Parsing.NonterminalParser(ToUtf32("EqualInstruction"), ToUtf32("EqualInstruction"), 2))), 
10753                     new System.Text.Parsing.ActionParser(ToUtf32("A11"), 
10754                         new System.Text.Parsing.NonterminalParser(ToUtf32("LessInstruction"), ToUtf32("LessInstruction"), 2)))));
10755             AddRule(new AddInstructionRule(ToUtf32("AddInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10756                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10757                     new System.Text.Parsing.GroupingParser(
10758                         new System.Text.Parsing.SequenceParser(
10759                             new System.Text.Parsing.SequenceParser(
10760                                 new System.Text.Parsing.SequenceParser(
10761                                     new System.Text.Parsing.SequenceParser(
10762                                         new System.Text.Parsing.KeywordParser(ToUtf32("add")), 
10763                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10764                                     new System.Text.Parsing.ExpectationParser(
10765                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10766                                 new System.Text.Parsing.ExpectationParser(
10767                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10768                             new System.Text.Parsing.ExpectationParser(
10769                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10770             AddRule(new SubInstructionRule(ToUtf32("SubInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10771                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10772                     new System.Text.Parsing.GroupingParser(
10773                         new System.Text.Parsing.SequenceParser(
10774                             new System.Text.Parsing.SequenceParser(
10775                                 new System.Text.Parsing.SequenceParser(
10776                                     new System.Text.Parsing.SequenceParser(
10777                                         new System.Text.Parsing.KeywordParser(ToUtf32("sub")), 
10778                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10779                                     new System.Text.Parsing.ExpectationParser(
10780                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10781                                 new System.Text.Parsing.ExpectationParser(
10782                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10783                             new System.Text.Parsing.ExpectationParser(
10784                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10785             AddRule(new MulInstructionRule(ToUtf32("MulInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10786                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10787                     new System.Text.Parsing.GroupingParser(
10788                         new System.Text.Parsing.SequenceParser(
10789                             new System.Text.Parsing.SequenceParser(
10790                                 new System.Text.Parsing.SequenceParser(
10791                                     new System.Text.Parsing.SequenceParser(
10792                                         new System.Text.Parsing.KeywordParser(ToUtf32("mul")), 
10793                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10794                                     new System.Text.Parsing.ExpectationParser(
10795                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10796                                 new System.Text.Parsing.ExpectationParser(
10797                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10798                             new System.Text.Parsing.ExpectationParser(
10799                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10800             AddRule(new DivInstructionRule(ToUtf32("DivInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10801                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10802                     new System.Text.Parsing.GroupingParser(
10803                         new System.Text.Parsing.SequenceParser(
10804                             new System.Text.Parsing.SequenceParser(
10805                                 new System.Text.Parsing.SequenceParser(
10806                                     new System.Text.Parsing.SequenceParser(
10807                                         new System.Text.Parsing.KeywordParser(ToUtf32("div")), 
10808                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10809                                     new System.Text.Parsing.ExpectationParser(
10810                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10811                                 new System.Text.Parsing.ExpectationParser(
10812                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10813                             new System.Text.Parsing.ExpectationParser(
10814                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10815             AddRule(new ModInstructionRule(ToUtf32("ModInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10816                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10817                     new System.Text.Parsing.GroupingParser(
10818                         new System.Text.Parsing.SequenceParser(
10819                             new System.Text.Parsing.SequenceParser(
10820                                 new System.Text.Parsing.SequenceParser(
10821                                     new System.Text.Parsing.SequenceParser(
10822                                         new System.Text.Parsing.KeywordParser(ToUtf32("mod")), 
10823                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10824                                     new System.Text.Parsing.ExpectationParser(
10825                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10826                                 new System.Text.Parsing.ExpectationParser(
10827                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10828                             new System.Text.Parsing.ExpectationParser(
10829                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10830             AddRule(new AndInstructionRule(ToUtf32("AndInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10831                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10832                     new System.Text.Parsing.GroupingParser(
10833                         new System.Text.Parsing.SequenceParser(
10834                             new System.Text.Parsing.SequenceParser(
10835                                 new System.Text.Parsing.SequenceParser(
10836                                     new System.Text.Parsing.SequenceParser(
10837                                         new System.Text.Parsing.KeywordParser(ToUtf32("and")), 
10838                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10839                                     new System.Text.Parsing.ExpectationParser(
10840                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10841                                 new System.Text.Parsing.ExpectationParser(
10842                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10843                             new System.Text.Parsing.ExpectationParser(
10844                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10845             AddRule(new OrInstructionRule(ToUtf32("OrInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10846                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10847                     new System.Text.Parsing.GroupingParser(
10848                         new System.Text.Parsing.SequenceParser(
10849                             new System.Text.Parsing.SequenceParser(
10850                                 new System.Text.Parsing.SequenceParser(
10851                                     new System.Text.Parsing.SequenceParser(
10852                                         new System.Text.Parsing.KeywordParser(ToUtf32("or")), 
10853                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10854                                     new System.Text.Parsing.ExpectationParser(
10855                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10856                                 new System.Text.Parsing.ExpectationParser(
10857                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10858                             new System.Text.Parsing.ExpectationParser(
10859                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10860             AddRule(new XorInstructionRule(ToUtf32("XorInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10861                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10862                     new System.Text.Parsing.GroupingParser(
10863                         new System.Text.Parsing.SequenceParser(
10864                             new System.Text.Parsing.SequenceParser(
10865                                 new System.Text.Parsing.SequenceParser(
10866                                     new System.Text.Parsing.SequenceParser(
10867                                         new System.Text.Parsing.KeywordParser(ToUtf32("xor")), 
10868                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10869                                     new System.Text.Parsing.ExpectationParser(
10870                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10871                                 new System.Text.Parsing.ExpectationParser(
10872                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10873                             new System.Text.Parsing.ExpectationParser(
10874                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10875             AddRule(new ShlInstructionRule(ToUtf32("ShlInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10876                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10877                     new System.Text.Parsing.GroupingParser(
10878                         new System.Text.Parsing.SequenceParser(
10879                             new System.Text.Parsing.SequenceParser(
10880                                 new System.Text.Parsing.SequenceParser(
10881                                     new System.Text.Parsing.SequenceParser(
10882                                         new System.Text.Parsing.KeywordParser(ToUtf32("shl")), 
10883                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10884                                     new System.Text.Parsing.ExpectationParser(
10885                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10886                                 new System.Text.Parsing.ExpectationParser(
10887                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10888                             new System.Text.Parsing.ExpectationParser(
10889                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10890             AddRule(new ShrInstructionRule(ToUtf32("ShrInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10891                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10892                     new System.Text.Parsing.GroupingParser(
10893                         new System.Text.Parsing.SequenceParser(
10894                             new System.Text.Parsing.SequenceParser(
10895                                 new System.Text.Parsing.SequenceParser(
10896                                     new System.Text.Parsing.SequenceParser(
10897                                         new System.Text.Parsing.KeywordParser(ToUtf32("shr")), 
10898                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10899                                     new System.Text.Parsing.ExpectationParser(
10900                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10901                                 new System.Text.Parsing.ExpectationParser(
10902                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10903                             new System.Text.Parsing.ExpectationParser(
10904                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10905             AddRule(new EqualInstructionRule(ToUtf32("EqualInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10906                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10907                     new System.Text.Parsing.GroupingParser(
10908                         new System.Text.Parsing.SequenceParser(
10909                             new System.Text.Parsing.SequenceParser(
10910                                 new System.Text.Parsing.SequenceParser(
10911                                     new System.Text.Parsing.SequenceParser(
10912                                         new System.Text.Parsing.KeywordParser(ToUtf32("equal")), 
10913                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10914                                     new System.Text.Parsing.ExpectationParser(
10915                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10916                                 new System.Text.Parsing.ExpectationParser(
10917                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10918                             new System.Text.Parsing.ExpectationParser(
10919                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10920             AddRule(new LessInstructionRule(ToUtf32("LessInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10921                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10922                     new System.Text.Parsing.GroupingParser(
10923                         new System.Text.Parsing.SequenceParser(
10924                             new System.Text.Parsing.SequenceParser(
10925                                 new System.Text.Parsing.SequenceParser(
10926                                     new System.Text.Parsing.SequenceParser(
10927                                         new System.Text.Parsing.KeywordParser(ToUtf32("less")), 
10928                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10929                                     new System.Text.Parsing.ExpectationParser(
10930                                         new System.Text.Parsing.NonterminalParser(ToUtf32("left"), ToUtf32("Operand"), 1))), 
10931                                 new System.Text.Parsing.ExpectationParser(
10932                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10933                             new System.Text.Parsing.ExpectationParser(
10934                                 new System.Text.Parsing.NonterminalParser(ToUtf32("right"), ToUtf32("Operand"), 1)))))));
10935             AddRule(new ParamInstructionRule(ToUtf32("ParamInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10936                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10937                     new System.Text.Parsing.KeywordParser(ToUtf32("param")))));
10938             AddRule(new LocalInstructionRule(ToUtf32("LocalInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10939                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10940                     new System.Text.Parsing.GroupingParser(
10941                         new System.Text.Parsing.SequenceParser(
10942                             new System.Text.Parsing.SequenceParser(
10943                                 new System.Text.Parsing.KeywordParser(ToUtf32("local")), 
10944                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10945                             new System.Text.Parsing.ExpectationParser(
10946                                 new System.Text.Parsing.NonterminalParser(ToUtf32("localType"), ToUtf32("TypeExpr"), 1)))))));
10947             AddRule(new LoadInstructionRule(ToUtf32("LoadInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10948                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10949                     new System.Text.Parsing.GroupingParser(
10950                         new System.Text.Parsing.SequenceParser(
10951                             new System.Text.Parsing.SequenceParser(
10952                                 new System.Text.Parsing.KeywordParser(ToUtf32("load")), 
10953                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10954                             new System.Text.Parsing.ExpectationParser(
10955                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1)))))));
10956             AddRule(new ElemAddrInstructionRule(ToUtf32("ElemAddrInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10957                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10958                     new System.Text.Parsing.GroupingParser(
10959                         new System.Text.Parsing.SequenceParser(
10960                             new System.Text.Parsing.SequenceParser(
10961                                 new System.Text.Parsing.SequenceParser(
10962                                     new System.Text.Parsing.SequenceParser(
10963                                         new System.Text.Parsing.KeywordParser(ToUtf32("elemaddr")), 
10964                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10965                                     new System.Text.Parsing.ExpectationParser(
10966                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1))), 
10967                                 new System.Text.Parsing.ExpectationParser(
10968                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10969                             new System.Text.Parsing.ExpectationParser(
10970                                 new System.Text.Parsing.NonterminalParser(ToUtf32("index"), ToUtf32("Operand"), 1)))))));
10971             AddRule(new PtrOffsetInstructionRule(ToUtf32("PtrOffsetInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10972                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10973                     new System.Text.Parsing.GroupingParser(
10974                         new System.Text.Parsing.SequenceParser(
10975                             new System.Text.Parsing.SequenceParser(
10976                                 new System.Text.Parsing.SequenceParser(
10977                                     new System.Text.Parsing.SequenceParser(
10978                                         new System.Text.Parsing.KeywordParser(ToUtf32("ptroffset")), 
10979                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10980                                     new System.Text.Parsing.ExpectationParser(
10981                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ptr"), ToUtf32("Operand"), 1))), 
10982                                 new System.Text.Parsing.ExpectationParser(
10983                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10984                             new System.Text.Parsing.ExpectationParser(
10985                                 new System.Text.Parsing.NonterminalParser(ToUtf32("offset"), ToUtf32("Operand"), 1)))))));
10986             AddRule(new PtrDiffInstructionRule(ToUtf32("PtrDiffInstruction"), GetScope(), Domain()->GetNextRuleId(), 
10987                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
10988                     new System.Text.Parsing.GroupingParser(
10989                         new System.Text.Parsing.SequenceParser(
10990                             new System.Text.Parsing.SequenceParser(
10991                                 new System.Text.Parsing.SequenceParser(
10992                                     new System.Text.Parsing.SequenceParser(
10993                                         new System.Text.Parsing.KeywordParser(ToUtf32("ptrdiff")), 
10994                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
10995                                     new System.Text.Parsing.ExpectationParser(
10996                                         new System.Text.Parsing.NonterminalParser(ToUtf32("leftPtr"), ToUtf32("Operand"), 1))), 
10997                                 new System.Text.Parsing.ExpectationParser(
10998                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
10999                             new System.Text.Parsing.ExpectationParser(
11000                                 new System.Text.Parsing.NonterminalParser(ToUtf32("rightPtr"), ToUtf32("Operand"), 1)))))));
11001             AddRule(new FunctionCallInstructionRule(ToUtf32("FunctionCallInstruction"), GetScope(), Domain()->GetNextRuleId(), 
11002                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11003                     new System.Text.Parsing.GroupingParser(
11004                         new System.Text.Parsing.SequenceParser(
11005                             new System.Text.Parsing.SequenceParser(
11006                                 new System.Text.Parsing.SequenceParser(
11007                                     new System.Text.Parsing.SequenceParser(
11008                                         new System.Text.Parsing.KeywordParser(ToUtf32("call")), 
11009                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
11010                                     new System.Text.Parsing.ExpectationParser(
11011                                         new System.Text.Parsing.NonterminalParser(ToUtf32("functionType"), ToUtf32("TypeExpr"), 1))), 
11012                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
11013                             new System.Text.Parsing.ExpectationParser(
11014                                 new System.Text.Parsing.NonterminalParser(ToUtf32("callee"), ToUtf32("Value"), 2)))))));
11015             AddRule(new TrapInstructionRule(ToUtf32("TrapInstruction"), GetScope(), Domain()->GetNextRuleId(), 
11016                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11017                     new System.Text.Parsing.GroupingParser(
11018                         new System.Text.Parsing.SequenceParser(
11019                             new System.Text.Parsing.SequenceParser(
11020                                 new System.Text.Parsing.SequenceParser(
11021                                     new System.Text.Parsing.SequenceParser(
11022                                         new System.Text.Parsing.SequenceParser(
11023                                             new System.Text.Parsing.SequenceParser(
11024                                                 new System.Text.Parsing.SequenceParser(
11025                                                     new System.Text.Parsing.SequenceParser(
11026                                                         new System.Text.Parsing.SequenceParser(
11027                                                             new System.Text.Parsing.SequenceParser(
11028                                                                 new System.Text.Parsing.SequenceParser(
11029                                                                     new System.Text.Parsing.SequenceParser(
11030                                                                         new System.Text.Parsing.KeywordParser(ToUtf32("trap")), 
11031                                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
11032                                                                     new System.Text.Parsing.ExpectationParser(
11033                                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type1"), ToUtf32("TypeExpr"), 1))), 
11034                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
11035                                                             new System.Text.Parsing.ExpectationParser(
11036                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("val1"), ToUtf32("Value"), 2))), 
11037                                                         new System.Text.Parsing.ExpectationParser(
11038                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
11039                                                     new System.Text.Parsing.ExpectationParser(
11040                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type2"), ToUtf32("TypeExpr"), 1))), 
11041                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
11042                                             new System.Text.Parsing.ExpectationParser(
11043                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("val2"), ToUtf32("Value"), 2))), 
11044                                         new System.Text.Parsing.ExpectationParser(
11045                                             new System.Text.Parsing.NonterminalParser(ToUtf32("Comma"), ToUtf32("Comma"), 0))), 
11046                                     new System.Text.Parsing.ExpectationParser(
11047                                         new System.Text.Parsing.NonterminalParser(ToUtf32("type3"), ToUtf32("TypeExpr"), 1))), 
11048                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
11049                             new System.Text.Parsing.ExpectationParser(
11050                                 new System.Text.Parsing.NonterminalParser(ToUtf32("val3"), ToUtf32("Value"), 2)))))));
11051             AddRule(new OperandRule(ToUtf32("Operand"), GetScope(), Domain()->GetNextRuleId(), 
11052                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11053                     new System.Text.Parsing.GroupingParser(
11054                         new System.Text.Parsing.SequenceParser(
11055                             new System.Text.Parsing.SequenceParser(
11056                                 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1), 
11057                                 new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
11058                             new System.Text.Parsing.ExpectationParser(
11059                                 new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("Value"), 2)))))));
11060             AddRule(new LabelRule(ToUtf32("Label"), GetScope(), Domain()->GetNextRuleId(), 
11061                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11062                     new System.Text.Parsing.TokenParser(
11063                         new System.Text.Parsing.SequenceParser(
11064                             new System.Text.Parsing.CharParser('@'), 
11065                             new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))))));
11066             AddRule(new ValueRule(ToUtf32("Value"), GetScope(), Domain()->GetNextRuleId(), 
11067                 new System.Text.Parsing.AlternativeParser(
11068                     new System.Text.Parsing.AlternativeParser(
11069                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11070                             new System.Text.Parsing.NonterminalParser(ToUtf32("IdValue"), ToUtf32("IdValue"), 2)), 
11071                         new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11072                             new System.Text.Parsing.NonterminalParser(ToUtf32("SymbolValue"), ToUtf32("SymbolValue"), 2))), 
11073                     new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
11074                         new System.Text.Parsing.NonterminalParser(ToUtf32("LiteralValue"), ToUtf32("LiteralValue"), 2)))));
11075             AddRule(new IdValueRule(ToUtf32("IdValue"), GetScope(), Domain()->GetNextRuleId(), 
11076                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11077                     new System.Text.Parsing.GroupingParser(
11078                         new System.Text.Parsing.SequenceParser(
11079                             new System.Text.Parsing.CharParser('$'), 
11080                             new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))))));
11081             AddRule(new SymbolValueRule(ToUtf32("SymbolValue"), GetScope(), Domain()->GetNextRuleId(), 
11082                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11083                     new System.Text.Parsing.TokenParser(
11084                         new System.Text.Parsing.SequenceParser(
11085                             new System.Text.Parsing.CharParser('@'), 
11086                             new System.Text.Parsing.NonterminalParser(ToUtf32("identifier"), ToUtf32("identifier"), 0))))));
11087             AddRule(new LiteralValueRule(ToUtf32("LiteralValue"), GetScope(), Domain()->GetNextRuleId(), 
11088                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11089                     new System.Text.Parsing.GroupingParser(
11090                         new System.Text.Parsing.PositiveParser(
11091                             new System.Text.Parsing.TokenParser(
11092                                 new System.Text.Parsing.DifferenceParser(
11093                                     new System.Text.Parsing.AnyCharParser(), 
11094                                     new System.Text.Parsing.GroupingParser(
11095                                         new System.Text.Parsing.AlternativeParser(
11096                                             new System.Text.Parsing.AlternativeParser(
11097                                                 new System.Text.Parsing.AlternativeParser(
11098                                                     new System.Text.Parsing.CharParser(','), 
11099                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
11100                                                 new System.Text.Parsing.CharParser(')')), 
11101                                             new System.Text.Parsing.NonterminalParser(ToUtf32("newline"), ToUtf32("newline"), 0))))))))));
11102             AddRule(new System.Text.Parsing.RuleParser(ToUtf32("S"), GetScope(), Domain()->GetNextRuleId(), 
11103                 new System.Text.Parsing.PositiveParser(
11104                     new System.Text.Parsing.CharSetParser(ToUtf32(" \t")))));
11105             AddRule(new System.Text.Parsing.RuleParser(ToUtf32("Comma"), GetScope(), Domain()->GetNextRuleId(), 
11106                 new System.Text.Parsing.SequenceParser(
11107                     new System.Text.Parsing.SequenceParser(
11108                         new System.Text.Parsing.OptionalParser(
11109                             new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)), 
11110                         new System.Text.Parsing.CharParser(',')), 
11111                     new System.Text.Parsing.OptionalParser(
11112                         new System.Text.Parsing.NonterminalParser(ToUtf32("S"), ToUtf32("S"), 0)))));
11113             AddRule(new VariableNameRule(ToUtf32("VariableName"), GetScope(), Domain()->GetNextRuleId(), 
11114                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11115                     new System.Text.Parsing.TokenParser(
11116                         new System.Text.Parsing.SequenceParser(
11117                             new System.Text.Parsing.GroupingParser(
11118                                 new System.Text.Parsing.AlternativeParser(
11119                                     new System.Text.Parsing.AlternativeParser(
11120                                         new System.Text.Parsing.IdStartParser(), 
11121                                         new System.Text.Parsing.CharParser('_')), 
11122                                     new System.Text.Parsing.CharParser('@'))), 
11123                             new System.Text.Parsing.KleeneStarParser(
11124                                 new System.Text.Parsing.GroupingParser(
11125                                     new System.Text.Parsing.AlternativeParser(
11126                                         new System.Text.Parsing.IdContParser(), 
11127                                         new System.Text.Parsing.CharParser('@')))))))));
11128             AddRule(new TypeDeclarationRule(ToUtf32("TypeDeclaration"), GetScope(), Domain()->GetNextRuleId(), 
11129                 new System.Text.Parsing.SequenceParser(
11130                     new System.Text.Parsing.SequenceParser(
11131                         new System.Text.Parsing.SequenceParser(
11132                             new System.Text.Parsing.NonterminalParser(ToUtf32("typeId"), ToUtf32("StrTypeId"), 1), 
11133                             new System.Text.Parsing.ExpectationParser(
11134                                 new System.Text.Parsing.CharParser('='))), 
11135                         new System.Text.Parsing.ExpectationParser(
11136                             new System.Text.Parsing.KeywordParser(ToUtf32("type")))), 
11137                     new System.Text.Parsing.GroupingParser(
11138                         new System.Text.Parsing.AlternativeParser(
11139                             new System.Text.Parsing.AlternativeParser(
11140                                 new System.Text.Parsing.NonterminalParser(ToUtf32("StructureType"), ToUtf32("StructureType"), 2), 
11141                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ArrayType"), ToUtf32("ArrayType"), 2)), 
11142                             new System.Text.Parsing.NonterminalParser(ToUtf32("FunctionType"), ToUtf32("FunctionType"), 2))))));
11143             AddRule(new StructureTypeRule(ToUtf32("StructureType"), GetScope(), Domain()->GetNextRuleId(), 
11144                 new System.Text.Parsing.SequenceParser(
11145                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11146                         new System.Text.Parsing.GroupingParser(
11147                             new System.Text.Parsing.SequenceParser(
11148                                 new System.Text.Parsing.SequenceParser(
11149                                     new System.Text.Parsing.CharParser('{'), 
11150                                     new System.Text.Parsing.OptionalParser(
11151                                         new System.Text.Parsing.GroupingParser(
11152                                             new System.Text.Parsing.ListParser(
11153                                                 new System.Text.Parsing.GroupingParser(
11154                                                     new System.Text.Parsing.SequenceParser(
11155                                                         new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11156                                                             new System.Text.Parsing.ExpectationParser(
11157                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("StrTypeId"), ToUtf32("StrTypeId"), 1))), 
11158                                                         new System.Text.Parsing.OptionalParser(
11159                                                             new System.Text.Parsing.GroupingParser(
11160                                                                 new System.Text.Parsing.SequenceParser(
11161                                                                     new System.Text.Parsing.SequenceParser(
11162                                                                         new System.Text.Parsing.SequenceParser(
11163                                                                             new System.Text.Parsing.CharParser(':'), 
11164                                                                             new System.Text.Parsing.StringParser(ToUtf32("offset"))), 
11165                                                                         new System.Text.Parsing.CharParser('=')), 
11166                                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("long"), ToUtf32("long"), 0)))))), 
11167                                                 new System.Text.Parsing.CharParser(','))))), 
11168                                 new System.Text.Parsing.ExpectationParser(
11169                                     new System.Text.Parsing.CharParser('}'))))), 
11170                     new System.Text.Parsing.OptionalParser(
11171                         new System.Text.Parsing.GroupingParser(
11172                             new System.Text.Parsing.SequenceParser(
11173                                 new System.Text.Parsing.SequenceParser(
11174                                     new System.Text.Parsing.SequenceParser(
11175                                         new System.Text.Parsing.SequenceParser(
11176                                             new System.Text.Parsing.SequenceParser(
11177                                                 new System.Text.Parsing.SequenceParser(
11178                                                     new System.Text.Parsing.KeywordParser(ToUtf32("size")), 
11179                                                     new System.Text.Parsing.CharParser('=')), 
11180                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("sz"), ToUtf32("long"), 0)), 
11181                                             new System.Text.Parsing.CharParser(',')), 
11182                                         new System.Text.Parsing.KeywordParser(ToUtf32("alignment"))), 
11183                                     new System.Text.Parsing.CharParser('=')), 
11184                                 new System.Text.Parsing.NonterminalParser(ToUtf32("al"), ToUtf32("long"), 0)))))));
11185             AddRule(new ArrayTypeRule(ToUtf32("ArrayType"), GetScope(), Domain()->GetNextRuleId(), 
11186                 new System.Text.Parsing.SequenceParser(
11187                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11188                         new System.Text.Parsing.GroupingParser(
11189                             new System.Text.Parsing.SequenceParser(
11190                                 new System.Text.Parsing.SequenceParser(
11191                                     new System.Text.Parsing.SequenceParser(
11192                                         new System.Text.Parsing.SequenceParser(
11193                                             new System.Text.Parsing.CharParser('['), 
11194                                             new System.Text.Parsing.ExpectationParser(
11195                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("size"), ToUtf32("long"), 0))), 
11196                                         new System.Text.Parsing.ExpectationParser(
11197                                             new System.Text.Parsing.CharParser('x'))), 
11198                                     new System.Text.Parsing.ExpectationParser(
11199                                         new System.Text.Parsing.NonterminalParser(ToUtf32("elementTypeId"), ToUtf32("StrTypeId"), 1))), 
11200                                 new System.Text.Parsing.ExpectationParser(
11201                                     new System.Text.Parsing.CharParser(']'))))), 
11202                     new System.Text.Parsing.OptionalParser(
11203                         new System.Text.Parsing.GroupingParser(
11204                             new System.Text.Parsing.SequenceParser(
11205                                 new System.Text.Parsing.SequenceParser(
11206                                     new System.Text.Parsing.SequenceParser(
11207                                         new System.Text.Parsing.SequenceParser(
11208                                             new System.Text.Parsing.SequenceParser(
11209                                                 new System.Text.Parsing.SequenceParser(
11210                                                     new System.Text.Parsing.KeywordParser(ToUtf32("size")), 
11211                                                     new System.Text.Parsing.CharParser('=')), 
11212                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("sz"), ToUtf32("long"), 0)), 
11213                                             new System.Text.Parsing.CharParser(',')), 
11214                                         new System.Text.Parsing.KeywordParser(ToUtf32("alignment"))), 
11215                                     new System.Text.Parsing.CharParser('=')), 
11216                                 new System.Text.Parsing.NonterminalParser(ToUtf32("al"), ToUtf32("long"), 0)))))));
11217             AddRule(new FunctionTypeRule(ToUtf32("FunctionType"), GetScope(), Domain()->GetNextRuleId(), 
11218                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11219                     new System.Text.Parsing.GroupingParser(
11220                         new System.Text.Parsing.SequenceParser(
11221                             new System.Text.Parsing.SequenceParser(
11222                                 new System.Text.Parsing.SequenceParser(
11223                                     new System.Text.Parsing.SequenceParser(
11224                                         new System.Text.Parsing.KeywordParser(ToUtf32("function")), 
11225                                         new System.Text.Parsing.ExpectationParser(
11226                                             new System.Text.Parsing.NonterminalParser(ToUtf32("returnTypeId"), ToUtf32("StrTypeId"), 1))), 
11227                                     new System.Text.Parsing.ExpectationParser(
11228                                         new System.Text.Parsing.CharParser('('))), 
11229                                 new System.Text.Parsing.OptionalParser(
11230                                     new System.Text.Parsing.GroupingParser(
11231                                         new System.Text.Parsing.ListParser(
11232                                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11233                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("paramType"), ToUtf32("StrTypeId"), 1)), 
11234                                             new System.Text.Parsing.CharParser(','))))), 
11235                             new System.Text.Parsing.ExpectationParser(
11236                                 new System.Text.Parsing.CharParser(')')))))));
11237             AddRule(new StrTypeIdRule(ToUtf32("StrTypeId"), GetScope(), Domain()->GetNextRuleId(), 
11238                 new System.Text.Parsing.SequenceParser(
11239                     new System.Text.Parsing.GroupingParser(
11240                         new System.Text.Parsing.AlternativeParser(
11241                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11242                                 new System.Text.Parsing.TokenParser(
11243                                     new System.Text.Parsing.SequenceParser(
11244                                         new System.Text.Parsing.StringParser(ToUtf32("$T")), 
11245                                         new System.Text.Parsing.NonterminalParser(ToUtf32("uint"), ToUtf32("uint"), 0)))), 
11246                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11247                                 new System.Text.Parsing.GroupingParser(
11248                                     new System.Text.Parsing.KeywordListParser(ToUtf32("identifier"), keywords0))))), 
11249                     new System.Text.Parsing.KleeneStarParser(
11250                         new System.Text.Parsing.GroupingParser(
11251                             new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
11252                                 new System.Text.Parsing.GroupingParser(
11253                                     new System.Text.Parsing.CharParser('*'))))))));
11254             AddRule(new TypeExprRule(ToUtf32("TypeExpr"), GetScope(), Domain()->GetNextRuleId(), 
11255                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11256                     new System.Text.Parsing.NonterminalParser(ToUtf32("PostfixTypeExpr"), ToUtf32("PostfixTypeExpr"), 1))));
11257             AddRule(new PostfixTypeExprRule(ToUtf32("PostfixTypeExpr"), GetScope(), Domain()->GetNextRuleId(), 
11258                 new System.Text.Parsing.SequenceParser(
11259                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11260                         new System.Text.Parsing.NonterminalParser(ToUtf32("PrimaryTypeExpr"), ToUtf32("PrimaryTypeExpr"), 1)), 
11261                     new System.Text.Parsing.KleeneStarParser(
11262                         new System.Text.Parsing.GroupingParser(
11263                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11264                                 new System.Text.Parsing.CharParser('*')))))));
11265             AddRule(new PrimaryTypeExprRule(ToUtf32("PrimaryTypeExpr"), GetScope(), Domain()->GetNextRuleId(), 
11266                 new System.Text.Parsing.AlternativeParser(
11267                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11268                         new System.Text.Parsing.NonterminalParser(ToUtf32("TypeId"), ToUtf32("TypeId"), 1)), 
11269                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11270                         new System.Text.Parsing.NonterminalParser(ToUtf32("PrimitiveType"), ToUtf32("PrimitiveType"), 1)))));
11271             AddRule(new TypeIdRule(ToUtf32("TypeId"), GetScope(), Domain()->GetNextRuleId(), 
11272                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11273                     new System.Text.Parsing.TokenParser(
11274                         new System.Text.Parsing.SequenceParser(
11275                             new System.Text.Parsing.StringParser(ToUtf32("$T")), 
11276                             new System.Text.Parsing.NonterminalParser(ToUtf32("uint"), ToUtf32("uint"), 0))))));
11277             AddRule(new PrimitiveTypeRule(ToUtf32("PrimitiveType"), GetScope(), Domain()->GetNextRuleId(), 
11278                 new System.Text.Parsing.AlternativeParser(
11279                     new System.Text.Parsing.AlternativeParser(
11280                         new System.Text.Parsing.AlternativeParser(
11281                             new System.Text.Parsing.AlternativeParser(
11282                                 new System.Text.Parsing.AlternativeParser(
11283                                     new System.Text.Parsing.AlternativeParser(
11284                                         new System.Text.Parsing.AlternativeParser(
11285                                             new System.Text.Parsing.AlternativeParser(
11286                                                 new System.Text.Parsing.AlternativeParser(
11287                                                     new System.Text.Parsing.AlternativeParser(
11288                                                         new System.Text.Parsing.AlternativeParser(
11289                                                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11290                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("VoidType"), ToUtf32("VoidType"), 1)), 
11291                                                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11292                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("BoolType"), ToUtf32("BoolType"), 1))), 
11293                                                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
11294                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("SByteType"), ToUtf32("SByteType"), 1))), 
11295                                                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
11296                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ByteType"), ToUtf32("ByteType"), 1))), 
11297                                                 new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
11298                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ShortType"), ToUtf32("ShortType"), 1))), 
11299                                             new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
11300                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("UShortType"), ToUtf32("UShortType"), 1))), 
11301                                         new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
11302                                             new System.Text.Parsing.NonterminalParser(ToUtf32("IntType"), ToUtf32("IntType"), 1))), 
11303                                     new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
11304                                         new System.Text.Parsing.NonterminalParser(ToUtf32("UIntType"), ToUtf32("UIntType"), 1))), 
11305                                 new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
11306                                     new System.Text.Parsing.NonterminalParser(ToUtf32("LongType"), ToUtf32("LongType"), 1))), 
11307                             new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
11308                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ULongType"), ToUtf32("ULongType"), 1))), 
11309                         new System.Text.Parsing.ActionParser(ToUtf32("A10"), 
11310                             new System.Text.Parsing.NonterminalParser(ToUtf32("FloatType"), ToUtf32("FloatType"), 1))), 
11311                     new System.Text.Parsing.ActionParser(ToUtf32("A11"), 
11312                         new System.Text.Parsing.NonterminalParser(ToUtf32("DoubleType"), ToUtf32("DoubleType"), 1)))));
11313             AddRule(new VoidTypeRule(ToUtf32("VoidType"), GetScope(), Domain()->GetNextRuleId(), 
11314                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11315                     new System.Text.Parsing.KeywordParser(ToUtf32("void")))));
11316             AddRule(new BoolTypeRule(ToUtf32("BoolType"), GetScope(), Domain()->GetNextRuleId(), 
11317                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11318                     new System.Text.Parsing.KeywordParser(ToUtf32("bool")))));
11319             AddRule(new SByteTypeRule(ToUtf32("SByteType"), GetScope(), Domain()->GetNextRuleId(), 
11320                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11321                     new System.Text.Parsing.KeywordParser(ToUtf32("sbyte")))));
11322             AddRule(new ByteTypeRule(ToUtf32("ByteType"), GetScope(), Domain()->GetNextRuleId(), 
11323                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11324                     new System.Text.Parsing.KeywordParser(ToUtf32("byte")))));
11325             AddRule(new ShortTypeRule(ToUtf32("ShortType"), GetScope(), Domain()->GetNextRuleId(), 
11326                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11327                     new System.Text.Parsing.KeywordParser(ToUtf32("short")))));
11328             AddRule(new UShortTypeRule(ToUtf32("UShortType"), GetScope(), Domain()->GetNextRuleId(), 
11329                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11330                     new System.Text.Parsing.KeywordParser(ToUtf32("ushort")))));
11331             AddRule(new IntTypeRule(ToUtf32("IntType"), GetScope(), Domain()->GetNextRuleId(), 
11332                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11333                     new System.Text.Parsing.KeywordParser(ToUtf32("int")))));
11334             AddRule(new UIntTypeRule(ToUtf32("UIntType"), GetScope(), Domain()->GetNextRuleId(), 
11335                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11336                     new System.Text.Parsing.KeywordParser(ToUtf32("uint")))));
11337             AddRule(new LongTypeRule(ToUtf32("LongType"), GetScope(), Domain()->GetNextRuleId(), 
11338                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11339                     new System.Text.Parsing.KeywordParser(ToUtf32("long")))));
11340             AddRule(new ULongTypeRule(ToUtf32("ULongType"), GetScope(), Domain()->GetNextRuleId(), 
11341                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11342                     new System.Text.Parsing.KeywordParser(ToUtf32("ulong")))));
11343             AddRule(new FloatTypeRule(ToUtf32("FloatType"), GetScope(), Domain()->GetNextRuleId(), 
11344                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11345                     new System.Text.Parsing.KeywordParser(ToUtf32("float")))));
11346             AddRule(new DoubleTypeRule(ToUtf32("DoubleType"), GetScope(), Domain()->GetNextRuleId(), 
11347                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11348                     new System.Text.Parsing.KeywordParser(ToUtf32("double")))));
11349             AddRule(new DataDefinitionRule(ToUtf32("DataDefinition"), GetScope(), Domain()->GetNextRuleId(), 
11350                 new System.Text.Parsing.SequenceParser(
11351                     new System.Text.Parsing.SequenceParser(
11352                         new System.Text.Parsing.SequenceParser(
11353                             new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1), 
11354                             new System.Text.Parsing.OptionalParser(
11355                                 new System.Text.Parsing.GroupingParser(
11356                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11357                                         new System.Text.Parsing.KeywordParser(ToUtf32("once")))))), 
11358                         new System.Text.Parsing.ExpectationParser(
11359                             new System.Text.Parsing.NonterminalParser(ToUtf32("name"), ToUtf32("VariableName"), 0))), 
11360                     new System.Text.Parsing.GroupingParser(
11361                         new System.Text.Parsing.AlternativeParser(
11362                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11363                                 new System.Text.Parsing.CharParser(';')), 
11364                             new System.Text.Parsing.SequenceParser(
11365                                 new System.Text.Parsing.ExpectationParser(
11366                                     new System.Text.Parsing.CharParser('=')), 
11367                                 new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
11368                                     new System.Text.Parsing.NonterminalParser(ToUtf32("Constant"), ToUtf32("Constant"), 1))))))));
11369             AddRule(new ConstantRule(ToUtf32("Constant"), GetScope(), Domain()->GetNextRuleId(), 
11370                 new System.Text.Parsing.AlternativeParser(
11371                     new System.Text.Parsing.AlternativeParser(
11372                         new System.Text.Parsing.AlternativeParser(
11373                             new System.Text.Parsing.AlternativeParser(
11374                                 new System.Text.Parsing.AlternativeParser(
11375                                     new System.Text.Parsing.AlternativeParser(
11376                                         new System.Text.Parsing.AlternativeParser(
11377                                             new System.Text.Parsing.AlternativeParser(
11378                                                 new System.Text.Parsing.AlternativeParser(
11379                                                     new System.Text.Parsing.AlternativeParser(
11380                                                         new System.Text.Parsing.AlternativeParser(
11381                                                             new System.Text.Parsing.AlternativeParser(
11382                                                                 new System.Text.Parsing.AlternativeParser(
11383                                                                     new System.Text.Parsing.AlternativeParser(
11384                                                                         new System.Text.Parsing.AlternativeParser(
11385                                                                             new System.Text.Parsing.AlternativeParser(
11386                                                                                 new System.Text.Parsing.AlternativeParser(
11387                                                                                     new System.Text.Parsing.AlternativeParser(
11388                                                                                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11389                                                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("ConversionConstant"), ToUtf32("ConversionConstant"), 1)), 
11390                                                                                         new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11391                                                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("ClsIdConstant"), ToUtf32("ClsIdConstant"), 1))), 
11392                                                                                     new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
11393                                                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("PtrConstant"), ToUtf32("PtrConstant"), 1))), 
11394                                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
11395                                                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("SymbolConstant"), ToUtf32("SymbolConstant"), 1))), 
11396                                                                             new System.Text.Parsing.ActionParser(ToUtf32("A4"), 
11397                                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("BoolConstant"), ToUtf32("BoolConstant"), 1))), 
11398                                                                         new System.Text.Parsing.ActionParser(ToUtf32("A5"), 
11399                                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("SByteConstant"), ToUtf32("SByteConstant"), 1))), 
11400                                                                     new System.Text.Parsing.ActionParser(ToUtf32("A6"), 
11401                                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("ByteConstant"), ToUtf32("ByteConstant"), 1))), 
11402                                                                 new System.Text.Parsing.ActionParser(ToUtf32("A7"), 
11403                                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ShortConstant"), ToUtf32("ShortConstant"), 1))), 
11404                                                             new System.Text.Parsing.ActionParser(ToUtf32("A8"), 
11405                                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("UShortConstant"), ToUtf32("UShortConstant"), 1))), 
11406                                                         new System.Text.Parsing.ActionParser(ToUtf32("A9"), 
11407                                                             new System.Text.Parsing.NonterminalParser(ToUtf32("IntConstant"), ToUtf32("IntConstant"), 1))), 
11408                                                     new System.Text.Parsing.ActionParser(ToUtf32("A10"), 
11409                                                         new System.Text.Parsing.NonterminalParser(ToUtf32("UIntConstant"), ToUtf32("UIntConstant"), 1))), 
11410                                                 new System.Text.Parsing.ActionParser(ToUtf32("A11"), 
11411                                                     new System.Text.Parsing.NonterminalParser(ToUtf32("LongConstant"), ToUtf32("LongConstant"), 1))), 
11412                                             new System.Text.Parsing.ActionParser(ToUtf32("A12"), 
11413                                                 new System.Text.Parsing.NonterminalParser(ToUtf32("ULongConstant"), ToUtf32("ULongConstant"), 1))), 
11414                                         new System.Text.Parsing.ActionParser(ToUtf32("A13"), 
11415                                             new System.Text.Parsing.NonterminalParser(ToUtf32("FloatConstant"), ToUtf32("FloatConstant"), 1))), 
11416                                     new System.Text.Parsing.ActionParser(ToUtf32("A14"), 
11417                                         new System.Text.Parsing.NonterminalParser(ToUtf32("DoubleConstant"), ToUtf32("DoubleConstant"), 1))), 
11418                                 new System.Text.Parsing.ActionParser(ToUtf32("A15"), 
11419                                     new System.Text.Parsing.NonterminalParser(ToUtf32("ArrayConstant"), ToUtf32("ArrayConstant"), 1))), 
11420                             new System.Text.Parsing.ActionParser(ToUtf32("A16"), 
11421                                 new System.Text.Parsing.NonterminalParser(ToUtf32("StructureConstant"), ToUtf32("StructureConstant"), 1))), 
11422                         new System.Text.Parsing.ActionParser(ToUtf32("A17"), 
11423                             new System.Text.Parsing.NonterminalParser(ToUtf32("StringConstant"), ToUtf32("StringConstant"), 1))), 
11424                     new System.Text.Parsing.ActionParser(ToUtf32("A18"), 
11425                         new System.Text.Parsing.NonterminalParser(ToUtf32("StringArrayConstant"), ToUtf32("StringArrayConstant"), 1)))));
11426             AddRule(new BoolConstantRule(ToUtf32("BoolConstant"), GetScope(), Domain()->GetNextRuleId(), 
11427                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11428                     new System.Text.Parsing.GroupingParser(
11429                         new System.Text.Parsing.SequenceParser(
11430                             new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("BoolType"), 1), 
11431                             new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("BoolValue"), 0))))));
11432             AddRule(new BoolValueRule(ToUtf32("BoolValue"), GetScope(), Domain()->GetNextRuleId(), 
11433                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11434                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("bool"), 0))));
11435             AddRule(new SByteConstantRule(ToUtf32("SByteConstant"), GetScope(), Domain()->GetNextRuleId(), 
11436                 new System.Text.Parsing.SequenceParser(
11437                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("SByteType"), 1), 
11438                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11439                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("SByteValue"), 0)))));
11440             AddRule(new SByteValueRule(ToUtf32("SByteValue"), GetScope(), Domain()->GetNextRuleId(), 
11441                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11442                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("sbyte"), 0))));
11443             AddRule(new ByteConstantRule(ToUtf32("ByteConstant"), GetScope(), Domain()->GetNextRuleId(), 
11444                 new System.Text.Parsing.SequenceParser(
11445                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ByteType"), 1), 
11446                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11447                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ByteValue"), 0)))));
11448             AddRule(new ByteValueRule(ToUtf32("ByteValue"), GetScope(), Domain()->GetNextRuleId(), 
11449                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11450                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("byte"), 0))));
11451             AddRule(new ShortConstantRule(ToUtf32("ShortConstant"), GetScope(), Domain()->GetNextRuleId(), 
11452                 new System.Text.Parsing.SequenceParser(
11453                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ShortType"), 1), 
11454                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11455                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ShortValue"), 0)))));
11456             AddRule(new ShortValueRule(ToUtf32("ShortValue"), GetScope(), Domain()->GetNextRuleId(), 
11457                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11458                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("short"), 0))));
11459             AddRule(new UShortConstantRule(ToUtf32("UShortConstant"), GetScope(), Domain()->GetNextRuleId(), 
11460                 new System.Text.Parsing.SequenceParser(
11461                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("UShortType"), 1), 
11462                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11463                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("UShortValue"), 0)))));
11464             AddRule(new UShortValueRule(ToUtf32("UShortValue"), GetScope(), Domain()->GetNextRuleId(), 
11465                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11466                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("ushort"), 0))));
11467             AddRule(new IntConstantRule(ToUtf32("IntConstant"), GetScope(), Domain()->GetNextRuleId(), 
11468                 new System.Text.Parsing.SequenceParser(
11469                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("IntType"), 1), 
11470                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11471                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("IntValue"), 0)))));
11472             AddRule(new IntValueRule(ToUtf32("IntValue"), GetScope(), Domain()->GetNextRuleId(), 
11473                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11474                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("int"), 0))));
11475             AddRule(new UIntConstantRule(ToUtf32("UIntConstant"), GetScope(), Domain()->GetNextRuleId(), 
11476                 new System.Text.Parsing.SequenceParser(
11477                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("UIntType"), 1), 
11478                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11479                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("UIntValue"), 0)))));
11480             AddRule(new UIntValueRule(ToUtf32("UIntValue"), GetScope(), Domain()->GetNextRuleId(), 
11481                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11482                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("uint"), 0))));
11483             AddRule(new LongConstantRule(ToUtf32("LongConstant"), GetScope(), Domain()->GetNextRuleId(), 
11484                 new System.Text.Parsing.SequenceParser(
11485                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("LongType"), 1), 
11486                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11487                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("LongValue"), 0)))));
11488             AddRule(new LongValueRule(ToUtf32("LongValue"), GetScope(), Domain()->GetNextRuleId(), 
11489                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11490                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("long"), 0))));
11491             AddRule(new ULongConstantRule(ToUtf32("ULongConstant"), GetScope(), Domain()->GetNextRuleId(), 
11492                 new System.Text.Parsing.SequenceParser(
11493                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("ULongType"), 1), 
11494                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11495                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("ULongValue"), 0)))));
11496             AddRule(new ULongValueRule(ToUtf32("ULongValue"), GetScope(), Domain()->GetNextRuleId(), 
11497                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11498                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("ulong"), 0))));
11499             AddRule(new FloatConstantRule(ToUtf32("FloatConstant"), GetScope(), Domain()->GetNextRuleId(), 
11500                 new System.Text.Parsing.SequenceParser(
11501                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("FloatType"), 1), 
11502                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11503                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("FloatValue"), 0)))));
11504             AddRule(new FloatValueRule(ToUtf32("FloatValue"), GetScope(), Domain()->GetNextRuleId(), 
11505                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11506                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("float"), 0))));
11507             AddRule(new DoubleConstantRule(ToUtf32("DoubleConstant"), GetScope(), Domain()->GetNextRuleId(), 
11508                 new System.Text.Parsing.SequenceParser(
11509                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("DoubleType"), 1), 
11510                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11511                         new System.Text.Parsing.NonterminalParser(ToUtf32("val"), ToUtf32("DoubleValue"), 0)))));
11512             AddRule(new DoubleValueRule(ToUtf32("DoubleValue"), GetScope(), Domain()->GetNextRuleId(), 
11513                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11514                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("double"), 0))));
11515             AddRule(new ConversionConstantRule(ToUtf32("ConversionConstant"), GetScope(), Domain()->GetNextRuleId(), 
11516                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11517                     new System.Text.Parsing.GroupingParser(
11518                         new System.Text.Parsing.SequenceParser(
11519                             new System.Text.Parsing.SequenceParser(
11520                                 new System.Text.Parsing.SequenceParser(
11521                                     new System.Text.Parsing.SequenceParser(
11522                                         new System.Text.Parsing.NonterminalParser(ToUtf32("targetType"), ToUtf32("TypeExpr"), 1), 
11523                                         new System.Text.Parsing.KeywordParser(ToUtf32("conv"))), 
11524                                     new System.Text.Parsing.ExpectationParser(
11525                                         new System.Text.Parsing.CharParser('('))), 
11526                                 new System.Text.Parsing.ExpectationParser(
11527                                     new System.Text.Parsing.NonterminalParser(ToUtf32("from"), ToUtf32("Constant"), 1))), 
11528                             new System.Text.Parsing.ExpectationParser(
11529                                 new System.Text.Parsing.CharParser(')')))))));
11530             AddRule(new ClsIdConstantRule(ToUtf32("ClsIdConstant"), GetScope(), Domain()->GetNextRuleId(), 
11531                 new System.Text.Parsing.SequenceParser(
11532                     new System.Text.Parsing.SequenceParser(
11533                         new System.Text.Parsing.SequenceParser(
11534                             new System.Text.Parsing.SequenceParser(
11535                                 new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1), 
11536                                 new System.Text.Parsing.KeywordParser(ToUtf32("clsid"))), 
11537                             new System.Text.Parsing.ExpectationParser(
11538                                 new System.Text.Parsing.CharParser('('))), 
11539                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11540                             new System.Text.Parsing.GroupingParser(
11541                                 new System.Text.Parsing.PositiveParser(
11542                                     new System.Text.Parsing.HexDigitParser())))), 
11543                     new System.Text.Parsing.ExpectationParser(
11544                         new System.Text.Parsing.CharParser(')')))));
11545             AddRule(new PtrConstantRule(ToUtf32("PtrConstant"), GetScope(), Domain()->GetNextRuleId(), 
11546                 new System.Text.Parsing.AlternativeParser(
11547                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11548                         new System.Text.Parsing.GroupingParser(
11549                             new System.Text.Parsing.SequenceParser(
11550                                 new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11551                                     new System.Text.Parsing.NonterminalParser(ToUtf32("type1"), ToUtf32("TypeExpr"), 1)), 
11552                                 new System.Text.Parsing.KeywordParser(ToUtf32("null"))))), 
11553                     new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
11554                         new System.Text.Parsing.GroupingParser(
11555                             new System.Text.Parsing.SequenceParser(
11556                                 new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
11557                                     new System.Text.Parsing.NonterminalParser(ToUtf32("type2"), ToUtf32("TypeExpr"), 1)), 
11558                                 new System.Text.Parsing.NonterminalParser(ToUtf32("LiteralValue"), ToUtf32("LiteralValue"), 2)))))));
11559             AddRule(new SymbolConstantRule(ToUtf32("SymbolConstant"), GetScope(), Domain()->GetNextRuleId(), 
11560                 new System.Text.Parsing.SequenceParser(
11561                     new System.Text.Parsing.NonterminalParser(ToUtf32("type"), ToUtf32("TypeExpr"), 1), 
11562                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11563                         new System.Text.Parsing.NonterminalParser(ToUtf32("SymbolValue"), ToUtf32("SymbolValue"), 2)))));
11564             AddRule(new ArrayConstantRule(ToUtf32("ArrayConstant"), GetScope(), Domain()->GetNextRuleId(), 
11565                 new System.Text.Parsing.SequenceParser(
11566                     new System.Text.Parsing.SequenceParser(
11567                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11568                             new System.Text.Parsing.CharParser('[')), 
11569                         new System.Text.Parsing.OptionalParser(
11570                             new System.Text.Parsing.GroupingParser(
11571                                 new System.Text.Parsing.ListParser(
11572                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11573                                         new System.Text.Parsing.NonterminalParser(ToUtf32("element"), ToUtf32("Constant"), 1)), 
11574                                     new System.Text.Parsing.CharParser(','))))), 
11575                     new System.Text.Parsing.CharParser(']'))));
11576             AddRule(new StructureConstantRule(ToUtf32("StructureConstant"), GetScope(), Domain()->GetNextRuleId(), 
11577                 new System.Text.Parsing.SequenceParser(
11578                     new System.Text.Parsing.SequenceParser(
11579                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11580                             new System.Text.Parsing.CharParser('{')), 
11581                         new System.Text.Parsing.OptionalParser(
11582                             new System.Text.Parsing.GroupingParser(
11583                                 new System.Text.Parsing.ListParser(
11584                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11585                                         new System.Text.Parsing.NonterminalParser(ToUtf32("member"), ToUtf32("Constant"), 1)), 
11586                                     new System.Text.Parsing.CharParser(','))))), 
11587                     new System.Text.Parsing.CharParser('}'))));
11588             AddRule(new StringConstantRule(ToUtf32("StringConstant"), GetScope(), Domain()->GetNextRuleId(), 
11589                 new System.Text.Parsing.TokenParser(
11590                     new System.Text.Parsing.SequenceParser(
11591                         new System.Text.Parsing.SequenceParser(
11592                             new System.Text.Parsing.CharParser('\"'), 
11593                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11594                                 new System.Text.Parsing.GroupingParser(
11595                                     new System.Text.Parsing.KleeneStarParser(
11596                                         new System.Text.Parsing.CharSetParser(ToUtf32("\""), true))))), 
11597                         new System.Text.Parsing.CharParser('\"')))));
11598             AddRule(new StringArrayConstantRule(ToUtf32("StringArrayConstant"), GetScope(), Domain()->GetNextRuleId(), 
11599                 new System.Text.Parsing.SequenceParser(
11600                     new System.Text.Parsing.SequenceParser(
11601                         new System.Text.Parsing.SequenceParser(
11602                             new System.Text.Parsing.NonterminalParser(ToUtf32("prefix"), ToUtf32("StringArrayPrefix"), 0), 
11603                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11604                                 new System.Text.Parsing.CharParser('['))), 
11605                         new System.Text.Parsing.OptionalParser(
11606                             new System.Text.Parsing.GroupingParser(
11607                                 new System.Text.Parsing.ListParser(
11608                                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11609                                         new System.Text.Parsing.NonterminalParser(ToUtf32("element"), ToUtf32("Constant"), 1)), 
11610                                     new System.Text.Parsing.CharParser(','))))), 
11611                     new System.Text.Parsing.CharParser(']'))));
11612             AddRule(new StringArrayPrefixRule(ToUtf32("StringArrayPrefix"), GetScope(), Domain()->GetNextRuleId(), 
11613                 new System.Text.Parsing.AlternativeParser(
11614                     new System.Text.Parsing.AlternativeParser(
11615                         new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11616                             new System.Text.Parsing.CharParser('w')), 
11617                         new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11618                             new System.Text.Parsing.CharParser('u'))), 
11619                     new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
11620                         new System.Text.Parsing.CharParser('b')))));
11621             AddRule(new MetadataRule(ToUtf32("Metadata"), GetScope(), Domain()->GetNextRuleId(), 
11622                 new System.Text.Parsing.SequenceParser(
11623                     new System.Text.Parsing.SequenceParser(
11624                         new System.Text.Parsing.SequenceParser(
11625                             new System.Text.Parsing.KeywordParser(ToUtf32("metadata")), 
11626                             new System.Text.Parsing.ExpectationParser(
11627                                 new System.Text.Parsing.CharParser('{'))), 
11628                         new System.Text.Parsing.KleeneStarParser(
11629                             new System.Text.Parsing.NonterminalParser(ToUtf32("MDStruct"), ToUtf32("MDStruct"), 1))), 
11630                     new System.Text.Parsing.ExpectationParser(
11631                         new System.Text.Parsing.CharParser('}')))));
11632             AddRule(new MDItemRule(ToUtf32("MDItem"), GetScope(), Domain()->GetNextRuleId(), 
11633                 new System.Text.Parsing.AlternativeParser(
11634                     new System.Text.Parsing.AlternativeParser(
11635                         new System.Text.Parsing.AlternativeParser(
11636                             new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11637                                 new System.Text.Parsing.NonterminalParser(ToUtf32("MDBool"), ToUtf32("MDBool"), 1)), 
11638                             new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11639                                 new System.Text.Parsing.NonterminalParser(ToUtf32("MDLong"), ToUtf32("MDLong"), 1))), 
11640                         new System.Text.Parsing.ActionParser(ToUtf32("A2"), 
11641                             new System.Text.Parsing.NonterminalParser(ToUtf32("MDString"), ToUtf32("MDString"), 1))), 
11642                     new System.Text.Parsing.ActionParser(ToUtf32("A3"), 
11643                         new System.Text.Parsing.NonterminalParser(ToUtf32("MDStructRef"), ToUtf32("MDStructRef"), 1)))));
11644             AddRule(new MDBoolRule(ToUtf32("MDBool"), GetScope(), Domain()->GetNextRuleId(), 
11645                 new System.Text.Parsing.AlternativeParser(
11646                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11647                         new System.Text.Parsing.KeywordParser(ToUtf32("true"))), 
11648                     new System.Text.Parsing.ActionParser(ToUtf32("A1"), 
11649                         new System.Text.Parsing.KeywordParser(ToUtf32("false"))))));
11650             AddRule(new MDLongRule(ToUtf32("MDLong"), GetScope(), Domain()->GetNextRuleId(), 
11651                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11652                     new System.Text.Parsing.NonterminalParser(ToUtf32("x"), ToUtf32("long"), 0))));
11653             AddRule(new MDStringRule(ToUtf32("MDString"), GetScope(), Domain()->GetNextRuleId(), 
11654                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11655                     new System.Text.Parsing.NonterminalParser(ToUtf32("s"), ToUtf32("string"), 0))));
11656             AddRule(new MDStructRefRule(ToUtf32("MDStructRef"), GetScope(), Domain()->GetNextRuleId(), 
11657                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11658                     new System.Text.Parsing.GroupingParser(
11659                         new System.Text.Parsing.SequenceParser(
11660                             new System.Text.Parsing.CharParser('!'), 
11661                             new System.Text.Parsing.NonterminalParser(ToUtf32("id"), ToUtf32("int"), 0))))));
11662             AddRule(new MDStructRule(ToUtf32("MDStruct"), GetScope(), Domain()->GetNextRuleId(), 
11663                 new System.Text.Parsing.SequenceParser(
11664                     new System.Text.Parsing.SequenceParser(
11665                         new System.Text.Parsing.SequenceParser(
11666                             new System.Text.Parsing.SequenceParser(
11667                                 new System.Text.Parsing.SequenceParser(
11668                                     new System.Text.Parsing.CharParser('!'), 
11669                                     new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11670                                         new System.Text.Parsing.NonterminalParser(ToUtf32("id"), ToUtf32("int"), 0))), 
11671                                 new System.Text.Parsing.CharParser('=')), 
11672                             new System.Text.Parsing.CharParser('{')), 
11673                         new System.Text.Parsing.OptionalParser(
11674                             new System.Text.Parsing.GroupingParser(
11675                                 new System.Text.Parsing.ListParser(
11676                                     new System.Text.Parsing.NonterminalParser(ToUtf32("field"), ToUtf32("MDField"), 2), 
11677                                     new System.Text.Parsing.CharParser(','))))), 
11678                     new System.Text.Parsing.CharParser('}'))));
11679             AddRule(new MDFieldRule(ToUtf32("MDField"), GetScope(), Domain()->GetNextRuleId(), 
11680                 new System.Text.Parsing.ActionParser(ToUtf32("A0"), 
11681                     new System.Text.Parsing.GroupingParser(
11682                         new System.Text.Parsing.SequenceParser(
11683                             new System.Text.Parsing.SequenceParser(
11684                                 new System.Text.Parsing.NonterminalParser(ToUtf32("fieldName"), ToUtf32("identifier"), 0), 
11685                                 new System.Text.Parsing.CharParser(':')), 
11686                             new System.Text.Parsing.NonterminalParser(ToUtf32("item"), ToUtf32("MDItem"), 1))))));
11687             SetSkipRuleName(ToUtf32("spaces"));
11688         }
11689         private List<ustring> keywords0;
11690     }
11691 } // cmsx.intermediate